public <T> T getHeader(String name, Object defaultValue, Class<T> type) {
        Object value = null;

        if (headers == null) {
             
            headers = createHeaders();
        }

        if (!headers.isEmpty()) {
            value = headers.get(name);
        }
        if (value == null) {
            value = defaultValue;
        }
        if (value == null) {
             
            if (boolean.class == type) {
                return (T) Boolean.FALSE;
            }
            return null;
        }

         
         
        if (type.isInstance(value)) {
            return (T) value;
        }

        Exchange e = getExchange();
        if (e != null) {
            return typeConverter.convertTo(type, e, value);
        } else {
            return typeConverter.convertTo(type, value);
        }
    }

    private SslHandler configureServerSSLOnDemand() {
        if (!consumer.getConfiguration().isSsl()) {
            return null;
        }

        if (consumer.getConfiguration().getSslHandler() != null) {
            return consumer.getConfiguration().getSslHandler();
        } else if (sslContext != null) {
            SSLEngine engine = sslContext.createSSLEngine();
            engine.setUseClientMode(false);
            engine.setNeedClientAuth(consumer.getConfiguration().isNeedClientAuth());
            if (consumer.getConfiguration().isHostnameVerification()) {
                SSLParameters sslParams = engine.getSSLParameters();
                sslParams.setEndpointIdentificationAlgorithm("HTTPS");
                engine.setSSLParameters(sslParams);
            }
            if (consumer.getConfiguration().getSslContextParameters() == null) {
                 
                engine.setEnabledProtocols(consumer.getConfiguration().getEnabledProtocols().split(","));
            }
            return new SslHandler(engine);
        }

        return null;
    }

    public boolean register(DevConsole console) {
        boolean result;
         
        if (getConsole(console.getId()).isPresent()) {
            return false;
        }
        result = consoles.add(console);
        if (result) {
            CamelContextAware.trySetCamelContext(console, camelContext);
             
            ServiceHelper.startService(console);
            LOG.debug("DevConsole with id {} successfully registered", console.getId());
        }
        return result;
    }

    private Function<Exchange, Object> updateVertex() {
        return exchange -> {
            try {
                ArangoVertexCollection vertexCollection = calculateVertexCollection();
                String key = (String) exchange.getMessage().getHeader(ARANGO_KEY);
                Object vertexDocument = exchange.getMessage().getMandatoryBody();
                return vertexCollection.updateVertex(key, vertexDocument);
            } catch (InvalidPayloadException e) {
                throw new RuntimeCamelException(INVALID_PAYLOAD_MESSAGE, e);
            }
        };
    }

    public static String resolveRestHostName(String host, RestConfiguration config) throws UnknownHostException {
        if (config.getHostNameResolver() == RestConfiguration.RestHostNameResolver.allLocalIp) {
            host = "0.0.0.0";
        } else if (config.getHostNameResolver() == RestConfiguration.RestHostNameResolver.localHostName) {
            host = HostUtils.getLocalHostName();
        } else if (config.getHostNameResolver() == RestConfiguration.RestHostNameResolver.localIp) {
            host = HostUtils.getLocalIp();
        }
        return host;
    }

    public void setDataObjectFormatIdentifierDocumentationReferences(
            List<String> dataObjectFormatIdentifierDocumentationReferences) {
        if (dataObjectFormatIdentifierDocumentationReferences == null) {
            throw new IllegalArgumentException("Parameter 'dataObjectFormatIdentifierDocumentationReferences' is null");
        }
        for (String ref : dataObjectFormatIdentifierDocumentationReferences) {
            if (ref == null || ref.isEmpty()) {
                throw new IllegalArgumentException(
                        "At least one reference of the identifier of the data object format is null or empty");
            }
        }
        this.dataObjectFormatIdentifierDocumentationReferences
                = new ArrayList<>(dataObjectFormatIdentifierDocumentationReferences);
    }

    public InputStream resource(String path, Object resource, Map<String, Object> queryParams) {
        DeleteOperation deleteOperation = dhis2Client.delete(path);
        if (queryParams != null) {
            for (Map.Entry<String, Object> queryParam : queryParams.entrySet()) {
                if (queryParam.getValue() instanceof List) {
                    for (String queryValue : (List<String>) queryParam.getValue()) {
                        deleteOperation.withParameter(queryParam.getKey(), queryValue);
                    }
                } else {
                    deleteOperation.withParameter(queryParam.getKey(), (String) queryParam.getValue());
                }
            }
        }

        if (resource != null) {
            deleteOperation.withResource(resource);
        }

        return deleteOperation.transfer().read();

    }

    private String parseDestinationName(String uri) {
         
        uri = uri.replaceFirst(scheme + "://", ":");
        uri = StringHelper.before(uri, "?", uri);

         
        String shortUri = StringHelper.before(uri, "::");
        final int lastIdx = lastIndexOneOf(uri, shortUri);
        if (lastIdx != -1) {
            return uri.substring(lastIdx + 1);
        } else {
            return null;
        }
    }

    public static String camelCaseToDash(String text) {
        if (text == null || text.isEmpty()) {
            return text;
        }
        char prev = 0;

        char[] arr = text.toCharArray();
        StringBuilder answer = new StringBuilder(arr.length < 13 ? 16 : arr.length + 8);

        for (int i = 0; i < arr.length; i++) {
            char ch = arr[i];

            if (ch == '-' || ch == '_') {
                answer.append("-");
            } else {
                if (Character.isUpperCase(ch) && prev != 0) {
                    char next;

                    if (i < arr.length - 1) {
                        next = arr[i + 1];
                    } else {
                        next = 0;
                    }

                    if (!Character.isUpperCase(prev) || next != 0 && Character.isLowerCase(next)) {
                        applyDashPrefix(prev, answer, ch);
                    } else {
                        answer.append(Character.toLowerCase(ch));
                    }
                } else {
                    answer.append(Character.toLowerCase(ch));
                }
            }
            prev = ch;
        }

        return answer.toString();
    }

    public Float toFloat(JsonNode node, Exchange exchange) throws Exception {
        if (node instanceof NumericNode) {
            NumericNode nn = (NumericNode) node;
            if (nn.isFloat()) {
                return nn.floatValue();
            }
        }
        String text = node.asText();
        return Float.valueOf(text);
    }

    public TabularData extendedInformation() {
        try {
            TabularData answer = new TabularDataSupport(CamelOpenMBeanTypes.endpointsUtilizationTabularType());

            EndpointUtilizationStatistics stats = getProcessor().getEndpointUtilizationStatistics();
            if (stats != null) {
                for (Map.Entry<String, Long> entry : stats.getStatistics().entrySet()) {
                    CompositeType ct = CamelOpenMBeanTypes.endpointsUtilizationCompositeType();
                    String url = entry.getKey();
                    if (sanitize) {
                        url = URISupport.sanitizeUri(url);
                    }

                    Long hits = entry.getValue();
                    if (hits == null) {
                        hits = 0L;
                    }

                    CompositeData data
                            = new CompositeDataSupport(ct, new String[] { "url", "hits" }, new Object[] { url, hits });
                    answer.put(data);
                }
            }
            return answer;
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    private void attachVolumeToDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
        String volumeId = exchange.getIn().getHeader(DigitalOceanHeaders.ID, String.class);
        String volumeName = exchange.getIn().getHeader(DigitalOceanHeaders.VOLUME_NAME, String.class);
        Integer dropletId = exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_ID, Integer.class);
        String region = exchange.getIn().getHeader(DigitalOceanHeaders.REGION, String.class);

        if (ObjectHelper.isEmpty(dropletId)) {
            throw new IllegalArgumentException(DigitalOceanHeaders.DROPLET_ID + " must be specified");
        }

        if (ObjectHelper.isEmpty(region)) {
            throw new IllegalArgumentException(DigitalOceanHeaders.REGION + " must be specified");
        }

        Action action;

        if (ObjectHelper.isNotEmpty(volumeName)) {
            action = getEndpoint().getDigitalOceanClient().attachVolumeByName(dropletId, volumeName, region);
            LOG.trace("Attach Volume {} to Droplet {} [{}] ", volumeName, dropletId, action);
        } else if (ObjectHelper.isNotEmpty(volumeId)) {
            action = getEndpoint().getDigitalOceanClient().attachVolume(dropletId, volumeId, region);
            LOG.trace("Attach Volume {} to Droplet {} [{}] ", volumeId, dropletId, action);
        } else {
            throw new IllegalArgumentException(
                    DigitalOceanHeaders.ID + " or " + DigitalOceanHeaders.VOLUME_NAME + " must be specified");
        }

        exchange.getMessage().setBody(action);
    }

    private static boolean isCompositeOperation(OperationName operationName) {
        switch (operationName) {
            case COMPOSITE:
            case COMPOSITE_BATCH:
            case COMPOSITE_TREE:
                return true;
            default:
                return false;
        }
    }

    public List<Processor> next() {
        if (!hasNext()) {
            return null;
        }
        List<Processor> answer = new ArrayList<>();
        if (tryProcessor != null) {
            answer.add(tryProcessor);
        }
        if (catchClauses != null && !catchClauses.isEmpty()) {
            answer.addAll(catchClauses);
        }
        if (finallyProcessor != null) {
            answer.add(finallyProcessor);
        }
        return answer;
    }

    public String resolveStaticUri(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        String destination = parseDestinationName(entry.getUri());
        if (destination != null) {
            String originalDestination = parseDestinationName(entry.getOriginalUri());
            if (!destination.equals(originalDestination)) {
                 
                String answer = entry.getUri();
                answer = StringHelper.replaceFirst(answer, destination, originalDestination);
                return answer;
            }
        }
        return null;
    }

    private static String pathAsKey(String path) {
         
        if (path == null || path.equals("/")) {
            path = "";
        }

         
        path = StringHelper.before(path, "?", path);

         
        if (path.endsWith("/")) {
            path = path.substring(0, path.length() - 1);
        }

        return UnsafeUriCharactersEncoder.encodeHttpURI(path);
    }

    private String getSecretKey(ImageRecognitionEndpoint endpoint) {
        if (!StringUtils.isEmpty(endpoint.getSecretKey())) {
            return endpoint.getSecretKey();
        } else if (endpoint.getServiceKeys() != null
                && !StringUtils.isEmpty(endpoint.getServiceKeys().getSecretKey())) {
            return endpoint.getServiceKeys().getSecretKey();
        } else {
            throw new IllegalArgumentException("authentication parameter 'secret key (SK)' not found");
        }
    }

    public static Set<String> asStringSet(Node node) {
        if (node == null) {
            return null;
        }

        final Set<String> answer;

        if (node.getNodeType() == NodeType.SCALAR) {
            answer = asStringSet(asText(node));
        } else if (node.getNodeType() == NodeType.SEQUENCE) {
            answer = new LinkedHashSet<>();
            for (Node item : asSequenceNode(node).getValue()) {
                answer.add(asText(item));
            }
        } else {
            throw new UnsupportedNodeTypeException(node);
        }

        return answer;
    }

    public MainConfigurationProperties withMainListeners(String listeners) {
        if (this.mainListenerClasses == null) {
            this.mainListenerClasses = "";
        }
        if (this.mainListenerClasses.isEmpty()) {
            this.mainListenerClasses = listeners;
        } else {
            this.mainListenerClasses = "," + listeners;
        }
        return this;
    }

    public void setKeystoreName(String keystoreName) {
        if (context != null && keystoreName != null) {
            KeyStore keystore = context.getRegistry().lookupByNameAndType(keystoreName, KeyStore.class);
            if (keystore != null) {
                setKeystore(keystore);
            }
        }
        if (keystoreName != null) {
            this.keystoreName = keystoreName;
        }
    }

    public Exchange create(Endpoint fromEndpoint, ExchangePattern exchangePattern) {
        Exchange answer = pool.poll();
        if (answer == null) {
             
            answer = DefaultPooledExchange.newFromEndpoint(fromEndpoint, exchangePattern);
            if (statisticsEnabled) {
                statistics.created.increment();
            }
        } else {
            if (statisticsEnabled) {
                statistics.acquired.increment();
            }
        }

         
        ((ResetableClock) answer.getClock()).reset();
        return answer;
    }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj == null) {
                return false;

            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            ProcessorNameAndMessageId other = (ProcessorNameAndMessageId) obj;
            if (messageId == null) {
                if (other.messageId != null) {
                    return false;
                }
            } else if (!messageId.equals(other.messageId)) {
                return false;
            }
            if (processorName == null) {
                if (other.processorName != null) {
                    return false;
                }
            } else if (!processorName.equals(other.processorName)) {
                return false;
            }
            return true;
        }

    public static Predicate isGreaterThanOrEqualTo(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue == null && rightValue == null) {
                     
                    return true;
                } else if (leftValue == null || rightValue == null) {
                     
                    return false;
                }

                return ObjectHelper.typeCoerceCompare(exchange.getContext().getTypeConverter(), leftValue, rightValue) >= 0;
            }

            protected String getOperationText() {
                return ">=";
            }
        };
    }

    public static String after(String text, String after) {
        if (text == null) {
            return null;
        }
        int pos = text.indexOf(after);
        if (pos == -1) {
            return null;
        }
        return text.substring(pos + after.length());
    }

    private void getKey(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
        Integer keyId = exchange.getIn().getHeader(DigitalOceanHeaders.ID, Integer.class);
        String fingerprint = exchange.getIn().getHeader(DigitalOceanHeaders.KEY_FINGERPRINT, String.class);
        Key key;

        if (ObjectHelper.isNotEmpty(keyId)) {
            key = getEndpoint().getDigitalOceanClient().getKeyInfo(keyId);
        } else if (ObjectHelper.isNotEmpty(fingerprint)) {
            key = getEndpoint().getDigitalOceanClient().getKeyInfo(fingerprint);
        } else {
            throw new IllegalArgumentException(
                    DigitalOceanHeaders.ID + " or " + DigitalOceanHeaders.KEY_FINGERPRINT + " must be specified");
        }
        LOG.trace("Key [{}] ", key);
        exchange.getMessage().setBody(key);
    }

    protected void loadResource(String resourceUri, XsltBuilder xslt) throws TransformerException, IOException {
        LOG.trace("{} loading schema resource: {}", this, resourceUri);
        Source source = xslt.getUriResolver().resolve(resourceUri, null);
        if (source == null) {
            throw new IOException("Cannot load schema resource " + resourceUri);
        } else {
            xslt.setTransformerSource(source);
        }
         
        cacheCleared = false;
    }

    private void configureFifoAttributes(SendMessageBatchRequestEntry.Builder request, Exchange exchange) {
        if (getEndpoint().getConfiguration().isFifoQueue()) {
             
            MessageGroupIdStrategy messageGroupIdStrategy = getEndpoint().getConfiguration().getMessageGroupIdStrategy();
            String messageGroupId = messageGroupIdStrategy.getMessageGroupId(exchange);
            request.messageGroupId(messageGroupId);

            MessageDeduplicationIdStrategy messageDeduplicationIdStrategy
                    = getEndpoint().getConfiguration().getMessageDeduplicationIdStrategy();
            String messageDeduplicationId = messageDeduplicationIdStrategy.getMessageDeduplicationId(exchange);
            request.messageDeduplicationId(messageDeduplicationId);

        }
    }

    public String getLastGoodProcessorId() {
        int idx = getProcessor().getLastGoodIndex();
        if (idx != -1) {
            LoadBalanceDefinition def = getDefinition();
            ProcessorDefinition<?> output = def.getOutputs().get(idx);
            if (output != null) {
                return output.getId();
            }
        }
        return null;
    }

    private void refreshStatusBecomingLeader() {
         
         
         
        long delay = this.lockConfiguration.getLeaseDurationMillis();
        LOG.info("{} Current pod owns the leadership, but it will be effective in {} seconds...", logPrefix,
                new BigDecimal(delay).divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_UP));

        try {
            Thread.sleep(delay);
        } catch (InterruptedException e) {
            LOG.warn("Thread interrupted", e);
            Thread.currentThread().interrupt();
        }

        LOG.info("{} Current pod is becoming the new leader now...", logPrefix);
        this.currentState = State.LEADER;
        this.serializedExecutor.execute(this::refreshStatus);
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer target = (org.apache.camel.component.infinispan.remote.InfinispanRemoteProducer) obj;
        switch (key) {
        case "query":
        case "QUERY": target.onQuery(exchange.getMessage()); return null;
        case "stats":
        case "STATS": target.onStats(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            OpenTelemetrySpanAdapter camelSpan = (OpenTelemetrySpanAdapter) ActiveSpanManager.getSpan(exchange);
            Span span = camelSpan.getOpenTelemetrySpan();
            if (span != null) {
                String tag = expression.evaluate(exchange, String.class);
                span.setAttribute(attributeName, tag);
            } else {
                LOG.warn("OpenTelemetry: Cannot find managed span for exchange: {}", exchange);
            }
        } catch (Exception e) {
            exchange.setException(e);
        } finally {
             
            callback.done(true);
        }

        return true;
    }

    public boolean exists() {
        if (!init) {
            try {
                URL u = URI.create(getLocation()).toURL();
                try (InputStream is = u.openStream()) {
                    cache = camelContext.getTypeConverter().tryConvertTo(byte[].class, is);
                }
            } catch (Exception e) {
                 
            }
            init = true;
        }
        return cache != null;
    }

    protected void doResume() throws Exception {
         
        if (!initialized) {
            doStart();
        } else {
            if (listenerContainer != null) {
                startListenerContainer();
            } else {
                LOG.warn(
                        "The listenerContainer is not instantiated. Probably there was a timeout during the Suspend operation. Please restart your consumer route.");
            }
        }
    }

    String lookup(String name, String key, String defaultValue) {
        String answer = null;
        Secret sec = getClient().secrets().withName(name).get();
        if (sec != null) {
             
            answer = sec.getStringData() != null ? sec.getStringData().get(key) : null;
            if (answer == null) {
                 
                answer = sec.getData() != null ? sec.getData().get(key) : null;
                if (answer != null) {
                    byte[] data = Base64.getDecoder().decode(answer);
                    if (data != null) {
                        answer = handleData(key, data);
                    }
                }
            }
        }
        if (answer == null) {
            return defaultValue;
        }

        return answer;
    }

    private void doUpdateList(Exchange exchange, SqlSession session) {
        Object result;
        Object in = getInput(exchange);
        if (in != null) {
             
            LOG.trace("Updating: {} using statement: {}", in, statement);
            result = session.update(statement, in);
            doProcessResult(exchange, result, session);
        } else {
            LOG.trace("Updating using statement: {}", statement);
            result = session.update(statement);
            doProcessResult(exchange, result, session);
        }
    }

    public static HttpString createMethod(Exchange exchange, UndertowEndpoint endpoint, boolean hasPayload)
            throws URISyntaxException {
         
         
        String queryString = exchange.getIn().getHeader(UndertowConstants.HTTP_QUERY, String.class);
         
        String uriString = exchange.getIn().getHeader(UndertowConstants.HTTP_URI, String.class);
         
        try {
            uriString = exchange.getContext().resolvePropertyPlaceholders(uriString);
        } catch (Exception e) {
            throw new RuntimeExchangeException("Cannot resolve property placeholders with uri: " + uriString, exchange, e);
        }
        if (uriString != null) {
            URI uri = new URI(uriString);
            queryString = uri.getQuery();
        }
        if (queryString == null) {
            queryString = endpoint.getHttpURI().getRawQuery();
        }

         
        HttpString answer;
        String m = exchange.getIn().getHeader(UndertowConstants.HTTP_METHOD, String.class);
        if (m != null) {
             
             
            m = m.toUpperCase();
            answer = new HttpString(m);
        } else if (queryString != null) {
             
            answer = Methods.GET;
        } else {
             
            answer = hasPayload ? Methods.POST : Methods.GET;
        }

        return answer;
    }

    private void reconnect() throws InterruptedException, IOException, SmackException, XMPPException {
        lock.lock();
        try {
            if (!connection.isConnected()) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Reconnecting to: {}", XmppEndpoint.getConnectionMessage(connection));
                }
                connection.connect();
            }
        } finally {
            lock.unlock();
        }
    }

    private String parseDestinationName(String uri) {
         
        uri = uri.replaceFirst(scheme + "://", ":");
        uri = StringHelper.before(uri, "?", uri);

         
        int pos = uri.lastIndexOf(':');
        if (pos != -1) {
            return uri.substring(pos + 1);
        } else {
            return null;
        }
    }

    protected String getHttpUrl(Exchange exchange, Endpoint endpoint) {
        Object url = exchange.getIn().getHeader(Exchange.HTTP_URL);
        if (url instanceof String) {
            return (String) url;
        } else {
            Object uri = exchange.getIn().getHeader(Exchange.HTTP_URI);
            if (uri instanceof String) {
                return (String) uri;
            } else {
                 
                int index = endpoint.getEndpointUri().lastIndexOf("http:");
                if (index != -1) {
                    return endpoint.getEndpointUri().substring(index);
                }
            }
        }
        return null;
    }

    protected void configureDataGramCodecFactory(
            final String type, final IoService service, final MinaConfiguration configuration) {
        ProtocolCodecFactory codecFactory = configuration.getCodec();
        if (codecFactory == null) {
            codecFactory = new MinaUdpProtocolCodecFactory(this.getEndpoint().getCamelContext());

            if (LOG.isDebugEnabled()) {
                LOG.debug("{}: Using CodecFactory: {}", type, codecFactory);
            }
        }

        addCodecFactory(service, codecFactory);
    }

    public static KafkaResumeStrategyConfigurationBuilder newBuilder() {
        final Properties producerProperties = KafkaResumeStrategyConfigurationBuilder.createProducerProperties();
        final Properties consumerProperties = KafkaResumeStrategyConfigurationBuilder.createConsumerProperties();

        KafkaResumeStrategyConfigurationBuilder builder = new KafkaResumeStrategyConfigurationBuilder(
                producerProperties,
                consumerProperties);

        String groupId = UUID.randomUUID().toString();
        LOG.debug("Creating consumer with {}[{}]", ConsumerConfig.GROUP_ID_CONFIG, groupId);
        builder.withGroupId(groupId);
        builder.withEnableAutoCommit(true);
        builder.withCacheFillPolicy(Cacheable.FillPolicy.MAXIMIZING);

        return builder;
    }

    protected Unmarshaller createUnmarshaller() throws JAXBException {
        Unmarshaller unmarshaller = getContext().createUnmarshaller();
        if (schema != null) {
            unmarshaller.setSchema(cachedSchema);
            unmarshaller.setEventHandler((ValidationEvent event) -> {
                 
                return event.getSeverity() < getSchemaSeverityLevel();
            });
        }

        return unmarshaller;
    }

        protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
            doBeforeParse(element);
            super.doParse(element, parserContext, builder);

             
            Binder<Node> binder;
            try {
                binder = getJaxbContext().createBinder();
            } catch (JAXBException e) {
                throw new BeanDefinitionStoreException("Failed to create the JAXB binder", e);
            }
            Object value = parseUsingJaxb(element, parserContext, binder);

            if (value instanceof CamelRouteContextFactoryBean) {
                CamelRouteContextFactoryBean factoryBean = (CamelRouteContextFactoryBean) value;
                builder.addPropertyValue("routes", factoryBean.getRoutes());
            }

             
            injectNamespaces(element, binder);
        }

        void cleanUpTempFile() {
             
            try {
                if (tempFile != null) {
                    FileUtil.deleteFile(tempFile);
                    tempFile = null;
                }
            } catch (Exception e) {
                LOG.warn("Error deleting temporary cache file: {}. This exception will be ignored.", tempFile, e);
            }
        }

    protected boolean isInputStreamNeededForObject(Object obj) {
        if (obj == null) {
            return false;
        }

        if (obj instanceof WrappedFile) {
            obj = ((WrappedFile<?>) obj).getFile();
        }
        if (obj instanceof File) {
             
             
            return true;
        }

         
        return false;
    }

    public void search(String soslQuery, Map<String, List<String>> headers, ResponseCallback callback) {
        try {

            String encodedQuery = urlEncode(soslQuery);
            final Request get = getRequest(HttpMethod.GET, versionUrl() + "search/?q=" + encodedQuery, headers);

             
            setAccessToken(get);

            doHttpRequest(get, new DelegatingClientCallback(callback));

        } catch (UnsupportedEncodingException e) {
            String msg = "Unexpected error: " + e.getMessage();
            callback.onResponse(null, Collections.emptyMap(), new SalesforceException(msg, e));
        }
    }

        public void onQuit(IRCUser user, String msg) {
            if (configuration.isOnQuit()) {
                Exchange exchange = createOnQuitExchange(user, msg);
                try {
                    getProcessor().process(exchange);
                } catch (Exception e) {
                    handleException(e);
                }
            }
        }

                public void artifactDownloaded(RepositoryEvent event) {
                    if (event.getArtifact() != null) {
                        Artifact a = event.getArtifact();

                        ArtifactRepository ar = event.getRepository();
                        String url = ar instanceof RemoteRepository ? ((RemoteRepository) ar).getUrl() : null;
                        String id = ar != null ? ar.getId() : null;
                        long elapsed = watch.takenAndRestart();
                        String version = a.isSnapshot() ? a.getBaseVersion() : a.getVersion();
                        remoteArtifactDownloadListener.artifactDownloaded(a.getGroupId(), a.getArtifactId(), version,
                                id, url, elapsed);
                    }
                }

    public static String getEffectiveAddress(Exchange exchange, String defaultAddress) {
        String retval = exchange.getIn().getHeader(CxfConstants.DESTINATION_OVERRIDE_URL, String.class);
        if (retval == null) {
            retval = defaultAddress;
        } else {
            LOG.trace("Client address is overridden by header '{}' to value '{}'",
                    CxfConstants.DESTINATION_OVERRIDE_URL, retval);
        }
        return retval;
    }

    public Map<String, String> getCeOverrides() {
        Map<String, String> answer = new HashMap<>();
        if (this.ceOverrides != null) {
            answer.putAll(this.ceOverrides);
        }
        if (this.metadata != null) {
            for (Map.Entry<String, String> entry : this.metadata.entrySet()) {
                if (entry.getKey().startsWith(Knative.KNATIVE_CE_OVERRIDE_PREFIX)) {
                    final String key = entry.getKey().substring(Knative.KNATIVE_CE_OVERRIDE_PREFIX.length());
                    final String val = entry.getValue();

                    answer.put(key, val);
                }
            }
        }

        return answer;
    }

    public static EventProcessorClient createEventProcessorClient(
            final EventHubsConfiguration configuration, final Consumer<EventContext> processEvent,
            final Consumer<ErrorContext> processError) {
        EventProcessorClientBuilder eventProcessorClientBuilder = new EventProcessorClientBuilder()
                .initialPartitionEventPosition(configuration.getEventPosition())
                .checkpointStore(createCheckpointStore(configuration))
                .consumerGroup(configuration.getConsumerGroupName())
                .retryOptions(configuration.getAmqpRetryOptions())
                .transportType(configuration.getAmqpTransportType())
                .processError(processError)
                .processEvent(processEvent);

        CredentialType type = configuration.getCredentialType();
        if (type == null) {
            type = CredentialType.CONNECTION_STRING;
        }
        if (CredentialType.CONNECTION_STRING.equals(type)) {
            return eventProcessorClientBuilder
                    .connectionString(buildConnectionString(configuration))
                    .buildEventProcessorClient();
        } else if (CredentialType.TOKEN_CREDENTIAL.equals(type)) {

            checkTokenCredentialConfiguration(configuration);
            return eventProcessorClientBuilder
                    .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                    .eventHubName(configuration.getEventHubName())
                    .credential(configuration.getTokenCredential())
                    .buildEventProcessorClient();
        }
        return eventProcessorClientBuilder
                .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                .eventHubName(configuration.getEventHubName())
                .credential(new DefaultAzureCredentialBuilder().build())
                .buildEventProcessorClient();
    }

    public static MainModel generateMainModel(JsonObject obj) {
        MainModel model = new MainModel();
        JsonArray mgrp = (JsonArray) obj.get("groups");
        for (Object entry : mgrp) {
            JsonObject mg = (JsonObject) entry;
            MainGroupModel group = new MainGroupModel();
            parseGroup(mg, group);
            model.addGroup(group);
        }
        JsonArray mprp = (JsonArray) obj.get("properties");
        for (Object entry : mprp) {
            JsonObject mp = (JsonObject) entry;
            MainOptionModel option = new MainOptionModel();
            parseOption(mp, option, mp.getString("name"));
            option.setSourceType(mp.getString("sourceType"));
            model.addOption(option);
        }
        return model;
    }

    protected void doListConfigMapsByLabels(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_CONFIGMAPS_LABELS, Map.class);
        ConfigMapList configMapsList;

        if (ObjectHelper.isEmpty(labels)) {
            LOG.error("Listing ConfigMaps by labels requires specifying labels");
            throw new IllegalArgumentException("Listing ConfigMaps by labels requires specifying labels");
        }

        if (ObjectHelper.isEmpty(namespace)) {
            configMapsList = getEndpoint().getKubernetesClient().configMaps().inAnyNamespace().withLabels(labels).list();
        } else {
            configMapsList = getEndpoint().getKubernetesClient().configMaps().inNamespace(namespace).withLabels(labels).list();
        }

        prepareOutboundMessage(exchange, configMapsList.getItems());
    }

    protected Object[] createProperties() {
        Object[] properties = new Object[7];
        properties[0] = asResultType();
        properties[1] = definition.getInstance();
        properties[2] = parseString(definition.getMethod());
        properties[3] = definition.getBeanType();
        properties[4] = parseString(definition.getRef());
        properties[5] = parseString(definition.getScope());
        properties[6] = parseString(definition.getValidate());
        return properties;
    }

    public static Expression fileNameNoExtensionSingleExpression() {
        return new ExpressionAdapter() {
            @Override
            public Object evaluate(Exchange exchange) {
                String name = exchange.getIn().getHeader(Exchange.FILE_NAME, String.class);
                return FileUtil.stripExt(name, true);
            }

            @Override
            public String toString() {
                return "file:name.noext.single";
            }
        };
    }

    private ListImagesCmd executeListImagesRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Images List Request");

        ListImagesCmd listImagesCmd = client.listImagesCmd();

        String filter = DockerHelper.getProperty(DockerConstants.DOCKER_FILTER, configuration, message, String.class);

        if (filter != null) {
            listImagesCmd.withLabelFilter(filter);
        }

        Boolean showAll = DockerHelper.getProperty(DockerConstants.DOCKER_SHOW_ALL, configuration, message, Boolean.class);

        if (showAll != null) {
            listImagesCmd.withShowAll(showAll);
        }

        return listImagesCmd;

    }

    public RestDefinition consumes(String mediaType) {
        if (getVerbs().isEmpty()) {
            this.consumes = mediaType;
        } else {
             
            VerbDefinition verb = getVerbs().get(getVerbs().size() - 1);
            verb.setConsumes(mediaType);
        }

        return this;
    }

    private void generateDownloadUrl(CloudFunctionsServiceClient client, Exchange exchange)
            throws InvalidPayloadException {
        GenerateDownloadUrlResponse response = null;
        if (getConfiguration().isPojoRequest()) {
            GenerateDownloadUrlRequest request = exchange.getIn().getMandatoryBody(GenerateDownloadUrlRequest.class);
            response = client.generateDownloadUrl(request);
        } else {
            CloudFunctionName cfName = CloudFunctionName.of(getConfiguration().getProject(),
                    getConfiguration().getLocation(), getConfiguration().getFunctionName());
            GenerateDownloadUrlRequest request = GenerateDownloadUrlRequest.newBuilder().setName(cfName.toString())
                    .build();
            response = client.generateDownloadUrl(request);
        }
        Message message = getMessageForResponse(exchange);
        message.setHeader(GoogleCloudFunctionsConstants.RESPONSE_OBJECT, response);
        message.setBody(response.getDownloadUrl());
    }

    private boolean existsRemote(ShareFileClient fileClient) {
        try {
            return Boolean.TRUE
                    .equals(fileClient.existsWithResponse(endpoint.getMetadataTimeout(), Context.NONE).getValue());
        } catch (ShareStorageException ex) {
             
            if (ex.getStatusCode() == HTTP_NOT_FOUND) {
                return false;
            }
            throw ex;
        }
    }

    private void processAbortJob(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        String jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
        bulkClient.changeJobState(jobId, JobStateEnum.ABORTED, determineHeaders(exchange),
                new JobResponseCallback() {
                    @Override
                    public void onResponse(Job job, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, job, headers, ex, callback);
                    }
                });
    }

    public static HealthCheck getHealthCheck(CamelContext context, String id) {
        HealthCheck answer = null;

        HealthCheckRegistry hcr = context.getCamelContextExtension().getContextPlugin(HealthCheckRegistry.class);
        if (hcr != null && hcr.isEnabled()) {
            Optional<HealthCheck> check = hcr.getCheck(id);
            if (check.isEmpty()) {
                 
                HealthCheckResolver resolver
                        = context.getCamelContextExtension().getContextPlugin(HealthCheckResolver.class);
                HealthCheck hc = resolver.resolveHealthCheck(id);
                if (hc != null) {
                    check = Optional.of(hc);
                    hcr.register(hc);
                }
            }
            if (check.isPresent()) {
                answer = check.get();
            }
        }
        return answer;
    }

    public void process(Exchange exchange) throws Exception {

        ClientConfigurations clientConfigurations = new ClientConfigurations();

        if (dmsClient == null) {
            LOG.debug("Initializing SDK client");
            this.dmsClient = endpoint.initClient();
            LOG.debug("Successfully initialized SDK client");
        }

        updateClientConfigs(exchange, clientConfigurations);

        switch (clientConfigurations.getOperation()) {
            case DMSOperations.CREATE_INSTANCE:
                createInstance(exchange, clientConfigurations);
                break;
            case DMSOperations.DELETE_INSTANCE:
                deleteInstance(exchange, clientConfigurations);
                break;
            case DMSOperations.LIST_INSTANCES:
                listInstances(exchange, clientConfigurations);
                break;
            case DMSOperations.QUERY_INSTANCE:
                queryInstance(exchange, clientConfigurations);
                break;
            case DMSOperations.UPDATE_INSTANCE:
                updateInstance(exchange, clientConfigurations);
                break;
            default:
                throw new UnsupportedOperationException(
                        String.format("%s is not a supported operation", clientConfigurations.getOperation()));
        }
    }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        ReplicationControllerList rcList;
        if (ObjectHelper.isEmpty(namespace)) {
            rcList = getEndpoint().getKubernetesClient().replicationControllers().inAnyNamespace().list();
        } else {
            rcList = getEndpoint().getKubernetesClient().replicationControllers().inNamespace(namespace).list();
        }

        prepareOutboundMessage(exchange, rcList.getItems());
    }

    protected int poll() throws Exception {
        final String containerName = getEndpoint().getConfiguration().getContainerName();
        final String blobName = getEndpoint().getConfiguration().getBlobName();
        final BlobContainerClient blobContainerClient
                = getEndpoint().getBlobServiceClient().getBlobContainerClient(containerName);

        Queue<Exchange> exchanges;

        try {
            if (ObjectHelper.isNotEmpty(blobName)) {
                 
                final Exchange exchange = createExchangeFromBlob(blobName, blobContainerClient);
                exchanges = new LinkedList<>();
                exchanges.add(exchange);
            } else {
                 
                exchanges = createBatchExchangesFromContainer(blobContainerClient);
            }
            return processBatch(CastUtils.cast(exchanges));
        } catch (BlobStorageException ex) {
            if (404 == ex.getStatusCode()) {
                return 0;
            } else {
                throw ex;
            }
        }
    }

    public static String valueOf(String regionId) {
        if (ObjectHelper.isEmpty(regionId)) {
            throw new IllegalArgumentException("Unexpected empty parameter: regionId.");
        } else {
            String endpoint = REGIONS.get(regionId.toLowerCase());
            if (ObjectHelper.isNotEmpty(endpoint)) {
                return endpoint;
            } else {
                throw new IllegalArgumentException("Unexpected regionId: " + regionId);
            }
        }
    }

        public Destination createDestination(Session session, String destinationName, boolean topic) throws JMSException {
            QueueReplyManager.this.lock.lock();
            try {
                 
                if (destination == null) {
                    destination = delegate.createDestination(session, destinationName, topic);
                    setReplyTo(destination);
                }
            } finally {
                QueueReplyManager.this.lock.unlock();
            }
            return destination;
        }

    protected void configureDataGramCodecFactory(
            final String type, final IoService service, final MinaConfiguration configuration) {
        ProtocolCodecFactory codecFactory = configuration.getCodec();
        if (codecFactory == null) {
            codecFactory = new MinaUdpProtocolCodecFactory(this.getEndpoint().getCamelContext());

            if (LOG.isDebugEnabled()) {
                LOG.debug("{}: Using CodecFactory: {}", type, codecFactory);
            }
        }

        addCodecFactory(service, codecFactory);
    }

    String lookup(String name, String key, String defaultValue) {
        String answer = null;
        Secret sec = getClient().secrets().withName(name).get();
        if (sec != null) {
             
            answer = sec.getStringData() != null ? sec.getStringData().get(key) : null;
            if (answer == null) {
                 
                answer = sec.getData() != null ? sec.getData().get(key) : null;
                if (answer != null) {
                    byte[] data = Base64.getDecoder().decode(answer);
                    if (data != null) {
                        answer = handleData(key, data);
                    }
                }
            }
        }
        if (answer == null) {
            return defaultValue;
        }

        return answer;
    }

    public Integer extractTokenCount(String chunk) throws JsonProcessingException {
        if (chunk == null || chunk.trim().isEmpty()) {
            return null;
        }
        JsonNode node = MAPPER.readTree(chunk);
        JsonNode type = node.get("type");

        if (type != null && "message_delta".equals(type.asText())) {
            JsonNode usage = node.get("usage");
            if (usage != null) {
                JsonNode outputTokens = usage.get("output_tokens");
                return outputTokens != null && !outputTokens.isNull() ? outputTokens.asInt() : null;
            }
        }
        return null;
    }

    protected TrustManagersParameters createInstance() throws Exception {
        TrustManagersParameters newInstance = new TrustManagersParameters();

        newInstance.setAlgorithm(algorithm);
        if (getKeyStore() != null) {
            getKeyStore().setCamelContext(getCamelContext());
            newInstance.setKeyStore(getKeyStore().getObject());
        }
        newInstance.setProvider(provider);
        newInstance.setCamelContext(getCamelContext());

        if (trustManager != null) {
            TrustManager tm = CamelContextHelper.mandatoryLookup(getCamelContext(), trustManager, TrustManager.class);
            newInstance.setTrustManager(tm);
        }

        return newInstance;
    }

    private CreateContainerCmd executeCreateContainerRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Create Container Request");

        String image = DockerHelper.getProperty(DockerConstants.DOCKER_IMAGE, configuration, message, String.class);

        ObjectHelper.notNull(image, "Image must be specified");

        CreateContainerCmd createContainerCmd = client.createContainerCmd(image);
        createContainerCmd.withHostConfig(newHostConfig());

        Boolean attachStdErr
                = DockerHelper.getProperty(DockerConstants.DOCKER_ATTACH_STD_ERR, configuration, message, Boolean.class);

        if (attachStdErr != null) {
            createContainerCmd.withAttachStderr(attachStdErr);
        }

        Boolean attachStdIn
                = DockerHelper.getProperty(DockerConstants.DOCKER_ATTACH_STD_IN, configuration, message, Boolean.class);

        if (attachStdIn != null) {
            createContainerCmd.withAttachStdin(attachStdIn);
        }

        Boolean attachStdOut
                = DockerHelper.getProperty(DockerConstants.DOCKER_ATTACH_STD_OUT, configuration, message, Boolean.class);

        if (attachStdOut != null) {
            createContainerCmd.withAttachStdout(attachStdOut);
        }

        Capability[] capAdd = DockerHelper.getArrayProperty(DockerConstants.DOCKER_CAP_ADD, message, Capability.class);

        if (capAdd != null) {
            createContainerCmd.getHostConfig().withCapAdd(capAdd);
        }

        Capability[] capDrop = DockerHelper.getArrayProperty(DockerConstants.DOCKER_CAP_DROP, message, Capability.class);

        if (capDrop != null) {
            createContainerCmd.getHostConfig().withCapDrop(capDrop);
        }

        String[] cmd = DockerHelper.parseDelimitedStringHeader(DockerConstants.DOCKER_CMD, message);

        if (cmd != null) {
            createContainerCmd.withCmd(cmd);
        }

        Integer cpuShares = DockerHelper.getProperty(DockerConstants.DOCKER_CPU_SHARES, configuration, message, Integer.class);

        if (cpuShares != null) {
            createContainerCmd.getHostConfig().withCpuShares(cpuShares);
        }

        Boolean disableNetwork
                = DockerHelper.getProperty(DockerConstants.DOCKER_DISABLE_NETWORK, configuration, message, Boolean.class);

        if (disableNetwork != null) {
            createContainerCmd.withNetworkDisabled(disableNetwork);
        }

        String[] dns = DockerHelper.parseDelimitedStringHeader(DockerConstants.DOCKER_DNS, message);

        if (dns != null) {
            createContainerCmd.getHostConfig().withDns(dns);
        }

        String domainName = DockerHelper.getProperty(DockerConstants.DOCKER_DOMAIN_NAME, configuration, message, String.class);

        if (domainName != null) {
            createContainerCmd.withDomainName(domainName);
        }

        String[] env = DockerHelper.parseDelimitedStringHeader(DockerConstants.DOCKER_ENV, message);

        if (env != null) {
            createContainerCmd.withEnv(env);
        }

        String[] entrypoint = DockerHelper.getArrayProperty(DockerConstants.DOCKER_ENTRYPOINT, message, String.class);

        if (entrypoint != null) {
            createContainerCmd.withEntrypoint(entrypoint);
        }

        ExposedPort[] exposedPorts
                = DockerHelper.getArrayProperty(DockerConstants.DOCKER_EXPOSED_PORTS, message, ExposedPort.class);

        if (exposedPorts != null) {
            createContainerCmd.withExposedPorts(exposedPorts);
        }

        HostConfig hostConfig
                = DockerHelper.getProperty(DockerConstants.DOCKER_HOST_CONFIG, configuration, message, HostConfig.class);

        if (hostConfig != null) {
            createContainerCmd.withHostConfig(hostConfig);
        }

        String hostName = DockerHelper.getProperty(DockerConstants.DOCKER_HOSTNAME, configuration, message, String.class);

        if (hostName != null) {
            createContainerCmd.withHostName(hostName);
        }

        Long memoryLimit = DockerHelper.getProperty(DockerConstants.DOCKER_MEMORY_LIMIT, configuration, message, Long.class);

        if (memoryLimit != null) {
            createContainerCmd.getHostConfig().withMemory(memoryLimit);
        }

        Long memorySwap = DockerHelper.getProperty(DockerConstants.DOCKER_MEMORY_SWAP, configuration, message, Long.class);

        if (memorySwap != null) {
            createContainerCmd.getHostConfig().withMemorySwap(memorySwap);
        }

        String name = DockerHelper.getProperty(DockerConstants.DOCKER_NAME, configuration, message, String.class);

        if (name != null) {
            createContainerCmd.withName(name);
        }

        String[] portSpecs = DockerHelper.parseDelimitedStringHeader(DockerConstants.DOCKER_PORT_SPECS, message);

        if (portSpecs != null) {
            createContainerCmd.withPortSpecs(portSpecs);
        }

        Boolean stdInOpen = DockerHelper.getProperty(DockerConstants.DOCKER_STD_IN_OPEN, configuration, message, Boolean.class);

        if (stdInOpen != null) {
            createContainerCmd.withStdinOpen(stdInOpen);
        }

        Boolean stdInOnce = DockerHelper.getProperty(DockerConstants.DOCKER_STD_IN_ONCE, configuration, message, Boolean.class);

        if (stdInOnce != null) {
            createContainerCmd.withStdInOnce(stdInOnce);
        }

        Boolean tty = DockerHelper.getProperty(DockerConstants.DOCKER_TTY, configuration, message, Boolean.class);

        if (tty != null) {
            createContainerCmd.withTty(tty);
        }

        String user = DockerHelper.getProperty(DockerConstants.DOCKER_USER, configuration, message, String.class);

        if (user != null) {
            createContainerCmd.withUser(user);
        }

        Volume[] volume = DockerHelper.getArrayProperty(DockerConstants.DOCKER_VOLUMES, message, Volume.class);

        if (volume != null) {
            createContainerCmd.withVolumes(volume);
        }

        Bind[] binds = DockerHelper.getArrayProperty(DockerConstants.DOCKER_BINDS, message, Bind.class);

        if (binds != null) {
            createContainerCmd.getHostConfig().withBinds(binds);
        }

        VolumesFrom[] volumesFrom
                = DockerHelper.getArrayProperty(DockerConstants.DOCKER_VOLUMES_FROM, message, VolumesFrom.class);

        if (volumesFrom != null) {
            createContainerCmd.getHostConfig().withVolumesFrom(volumesFrom);
        }

        String workingDir = DockerHelper.getProperty(DockerConstants.DOCKER_WORKING_DIR, configuration, message, String.class);

        if (workingDir != null) {
            createContainerCmd.withWorkingDir(workingDir);
        }

        return createContainerCmd;

    }

    protected List<SimpleNode> parseTokens() {
        clear();

         
        nextToken();
        while (!token.getType().isEol()) {
             
            templateText();
            functionText();
            unaryOperator();
            nextToken();
        }

         
         
         

         
        parseAndCreateAstModel();
         
        prepareBlocks();
         
        prepareUnaryExpressions();

        return nodes;
    }

    public KeyPair rotateKey(String oldKeyId, String newKeyId, String algorithm) throws Exception {
        LOG.info("Rotating key from {} to {}", oldKeyId, newKeyId);

         
        KeyMetadata oldMetadata = getKeyMetadata(oldKeyId);
        if (oldMetadata == null) {
            throw new IllegalArgumentException("Old key not found: " + oldKeyId);
        }

         
        oldMetadata.setStatus(KeyMetadata.KeyStatus.DEPRECATED);
        updateKeyMetadata(oldKeyId, oldMetadata);

         
        KeyPair newKeyPair = generateKeyPair(algorithm, newKeyId);

        LOG.info("Key rotation completed in Vault: {} -> {}", oldKeyId, newKeyId);
        return newKeyPair;
    }

    private WatchKey registerPathToWatcher(WatchEvent.Modifier modifier, Path path, WatchService watcher) throws IOException {
        WatchKey key;
        if (modifier != null) {
            key = path.register(watcher, new WatchEvent.Kind<?>[] { ENTRY_CREATE, ENTRY_MODIFY }, modifier);
        } else {
            key = path.register(watcher, ENTRY_CREATE, ENTRY_MODIFY);
        }
        return key;
    }

    public void configureProperties(Map<String, Object> options) {
         
        Map<String, Object> query = new CaseInsensitiveMap();
        Map<String, Object> known = new CaseInsensitiveMap();
        options.forEach((k, v) -> {
            if (k.startsWith("$")) {
                query.put(k, v);
            } else {
                known.put(k, v);
            }
        });
        options.keySet().removeIf(known::containsKey);

         
        PropertyConfigurer configurer = getComponent().getEndpointPropertyConfigurer();
        if (configurer instanceof ExtendedPropertyConfigurerGetter) {
            ExtendedPropertyConfigurerGetter getter = (ExtendedPropertyConfigurerGetter) configurer;
            for (String name : getter.getAllOptions(this).keySet()) {
                if (known.containsKey(name)) {
                    Object value = known.get(name);
                    boolean hit = configurer.configure(getCamelContext(), this, name, value, true);
                    if (hit) {
                        known.remove(name);
                    }
                }
            }
        }
         
        configurer = PluginHelper.getConfigurerResolver(getCamelContext())
                .resolvePropertyConfigurer(configuration.getClass().getName(), getCamelContext());
        if (configurer != null) {
            PropertyBindingSupport.build()
                    .withConfigurer(configurer)
                    .withIgnoreCase(true)
                    .withTarget(configuration)
                    .withCamelContext(getCamelContext())
                    .withProperties(known)
                    .withRemoveParameters(true)
                    .bind();
        }
        super.configureProperties(known);
        if (!known.isEmpty()) {
             
            query.putAll(known);
        }
         
        options.keySet().removeIf(query::containsKey);
         
        parseQueryParams(query);
         
        options.putAll(query);
    }

    public Processor createErrorHandler(Processor processor) throws Exception {
        String uri = parseString(definition.getDeadLetterUri());
        ObjectHelper.notNull(uri, "deadLetterUri", this);

         
        RedeliveryPolicy redeliveryPolicy = resolveRedeliveryPolicy(definition, camelContext);
        CamelLogger logger = resolveLogger(definition);

        Processor deadLetterProcessor = createDeadLetterChannelProcessor(uri);

        DeadLetterChannel answer = new DeadLetterChannel(
                camelContext, processor, logger,
                getProcessor(definition.getOnRedeliveryProcessor(), definition.getOnRedeliveryRef()),
                redeliveryPolicy, deadLetterProcessor, uri,
                parseBoolean(definition.getDeadLetterHandleNewException(), true),
                parseBoolean(definition.getUseOriginalMessage(), false),
                parseBoolean(definition.getUseOriginalBody(), false),
                resolveRetryWhilePolicy(definition, camelContext),
                getExecutorService(definition.getExecutorServiceBean(), definition.getExecutorServiceRef()),
                getProcessor(definition.getOnPrepareFailureProcessor(), definition.getOnPrepareFailureRef()),
                getProcessor(definition.getOnExceptionOccurredProcessor(), definition.getOnExceptionOccurredRef()));
         
        configure(answer);
        return answer;
    }

    public static Predicate or(final Predicate left, final Predicate right) {
        notNull(left, "left");
        notNull(right, "right");
        return new Predicate() {
            public boolean matches(Exchange exchange) {
                return left.matches(exchange) || right.matches(exchange);
            }

            @Override
            public void init(CamelContext camelContext) {
                left.initPredicate(camelContext);
                right.initPredicate(camelContext);
            }

            @Override
            public String toString() {
                return "(" + left + ") or (" + right + ")";
            }
        };
    }

    protected boolean isMatched(Supplier<GenericFile<SftpRemoteFile>> file, String doneFileName, SftpRemoteFile[] files) {
        String onlyName = FileUtil.stripPath(doneFileName);

        for (SftpRemoteFile f : files) {
            if (f.getFilename().equals(onlyName)) {
                return true;
            }
        }

        LOG.trace("Done file: {} does not exist", doneFileName);
        return false;
    }

    protected String logStep(StartupStep step) {
        long delta = step.getDuration();
        String pad = StringHelper.padString(step.getLevel());
        String out = String.format("%s", pad + step.getType());
        String out2 = String.format("%6s ms", delta);
        String out3;
        if (step.getName() != null) {
            out3 = String.format("%s (%s)", step.getDescription(), step.getName());
        } else {
            out3 = String.format("%s", step.getDescription());
        }
        return String.format("%s : %s - %s", out2, out, out3);
    }

    public KeyManagersParameters getObject() throws Exception {
        if (this.isSingleton()) {
            if (instance == null) {
                instance = createInstance();
            }

            return instance;
        } else {
            return createInstance();
        }
    }

    private void getModel(Exchange exchange) {
        SpeechToText stt = getEndpoint().getSttClient();
        if (stt == null) {
            throw new IllegalStateException("STT client not initialized");
        }

        String modelName = exchange.getIn().getHeader(WatsonSpeechToTextConstants.MODEL_NAME, String.class);
        if (modelName == null) {
            modelName = exchange.getIn().getBody(String.class);
        }

        if (modelName == null || modelName.isBlank()) {
            throw new IllegalArgumentException("Model name must be specified");
        }

        LOG.trace("Getting model information for: {}", modelName);

        GetModelOptions options = new GetModelOptions.Builder()
                .modelId(modelName)
                .build();

        SpeechModel model = stt.getModel(options).execute().getResult();

        Message message = getMessageForResponse(exchange);
        message.setBody(model);
    }

    private void generateComponentConfigurer(
            UriEndpoint uriEndpoint, String scheme, String[] schemes, ComponentModel componentModel,
            ComponentModel parentData) {

        if (!uriEndpoint.generateConfigurer()) {
            return;
        }
         
        if (isFirstScheme(scheme, schemes)) {
            return;
        }
        String pfqn;
        boolean hasSuper;

        Class<?> superClazz = loadClass(componentModel.getJavaType()).getSuperclass();
        if (parentData != null && superClazz.getName().equals(parentData.getJavaType())) {
             
            pfqn = parentData.getJavaType() + "Configurer";
            hasSuper = true;
        } else {
            pfqn = "org.apache.camel.support.component.PropertyConfigurerSupport";
            hasSuper = false;
            parentData = null;
        }
        String psn = pfqn.substring(pfqn.lastIndexOf('.') + 1);
        String fqComponentClassName = componentModel.getJavaType();
        String componentClassName = fqComponentClassName.substring(fqComponentClassName.lastIndexOf('.') + 1);
        String className = componentClassName + "Configurer";
        String packageName = fqComponentClassName.substring(0, fqComponentClassName.lastIndexOf('.'));
        String fqClassName = packageName + "." + className;

        List<ComponentOptionModel> options;
        if (parentData != null) {
            Set<String> parentOptionsNames = parentData.getComponentOptions().stream()
                    .map(ComponentOptionModel::getName).collect(Collectors.toSet());
            options = componentModel.getComponentOptions().stream().filter(o -> !parentOptionsNames.contains(o.getName()))
                    .toList();
        } else {
            options = componentModel.getComponentOptions();
        }
        generatePropertyConfigurer(packageName, className, fqClassName, componentClassName,
                pfqn, psn,
                componentModel.getScheme() + "-component", hasSuper, true,
                options, componentModel);
    }

    private static String doGetHost(RestConfiguration config) throws UnknownHostException {
        String host = config.getHost();
        if (ObjectHelper.isEmpty(host)) {
            if (config.getHostNameResolver() == RestConfiguration.RestHostNameResolver.allLocalIp) {
                host = "0.0.0.0";
            } else if (config.getHostNameResolver() == RestConfiguration.RestHostNameResolver.localHostName) {
                host = HostUtils.getLocalHostName();
            } else if (config.getHostNameResolver() == RestConfiguration.RestHostNameResolver.localIp) {
                host = HostUtils.getLocalIp();
            }
        }
        return host;
    }

        int asNum() {
            switch (this) {
                case LE:
                    return ComparisonTerm.LE;
                case LT:
                    return ComparisonTerm.LT;
                case EQ:
                    return ComparisonTerm.EQ;
                case NE:
                    return ComparisonTerm.NE;
                case GT:
                    return ComparisonTerm.GT;
                case GE:
                    return ComparisonTerm.GE;
                default:
                    throw new IllegalArgumentException("Unknown comparison " + this);
            }
        }

    public void process(Exchange exchange) throws Exception {

        Map<String, Object> headers = exchange.getIn().getHeaders();

         
        Integer pos = null;

        if (headers.containsKey(HazelcastConstants.OBJECT_POS)) {
            if (!(headers.get(HazelcastConstants.OBJECT_POS) instanceof Integer)) {
                throw new IllegalArgumentException("OBJECT_POS Should be of type Integer");
            }
            pos = (Integer) headers.get(HazelcastConstants.OBJECT_POS);
        }

        final HazelcastOperation operation = lookupOperation(exchange);

        switch (operation) {

            case ADD:
                this.add(pos, exchange);
                break;

            case GET:
                this.get(pos, exchange);
                break;

            case SET_VALUE:
                this.set(pos, exchange);
                break;

            case REMOVE_VALUE:
                this.remove(pos, exchange);
                break;

            case CLEAR:
                this.clear();
                break;

            case ADD_ALL:
                this.addAll(pos, exchange);
                break;

            case REMOVE_ALL:
                this.removeAll(exchange);
                break;

            case RETAIN_ALL:
                this.retainAll(exchange);
                break;

            case GET_ALL:
                this.getAll(exchange);
                break;

            default:
                throw new IllegalArgumentException(
                        String.format("The value '%s' is not allowed for parameter '%s' on the LIST cache.", operation,
                                HazelcastConstants.OPERATION));
        }

         
        HazelcastComponentHelper.copyHeaders(exchange);
    }

    protected void configureDefaultCodecFactory(String type, IoService service) {
        if (configuration.isTextline()) {
            Charset charset = getEncodingParameter(type, configuration);
            LineDelimiter delimiter = getLineDelimiterParameter(configuration.getTextlineDelimiter());
            MinaTextLineCodecFactory codecFactory = new MinaTextLineCodecFactory(charset, delimiter);
            if (configuration.getEncoderMaxLineLength() > 0) {
                codecFactory.setEncoderMaxLineLength(configuration.getEncoderMaxLineLength());
            }
            if (configuration.getDecoderMaxLineLength() > 0) {
                codecFactory.setDecoderMaxLineLength(configuration.getDecoderMaxLineLength());
            }
            addCodecFactory(service, codecFactory);
            LOG.debug("{}: Using TextLineCodecFactory: {} using encoding: {} line delimiter: {}({})",
                    type, codecFactory, charset, configuration.getTextlineDelimiter(), delimiter);
            LOG.debug("Encoder maximum line length: {}. Decoder maximum line length: {}",
                    codecFactory.getEncoderMaxLineLength(), codecFactory.getDecoderMaxLineLength());
        } else {
            ObjectSerializationCodecFactory codecFactory = new ObjectSerializationCodecFactory();
            if (configuration.getObjectCodecPattern() != null) {
                String[] arr = configuration.getObjectCodecPattern().split(",");
                codecFactory.accept(arr);
            }
            addCodecFactory(service, codecFactory);
            LOG.debug("{}: Using ObjectSerializationCodecFactory: {}", type, codecFactory);
        }
    }

    protected ScheduledExecutorService getExecutorService(
            ScheduledExecutorService executorService, String executorServiceRef) {
        lock.lock();
        try {
            if (executorService == null || executorService.isShutdown()) {
                 
                 
                if (executorServiceRef != null) {
                    executorService = lookupByNameAndType(executorServiceRef, ScheduledExecutorService.class);
                    if (executorService == null) {
                        ExecutorServiceManager manager = camelContext.getExecutorServiceManager();
                        ThreadPoolProfile profile = manager.getThreadPoolProfile(executorServiceRef);
                        executorService = manager.newScheduledThreadPool(this, executorServiceRef, profile);
                    }
                    if (executorService == null) {
                        throw new IllegalArgumentException("ExecutorService " + executorServiceRef + " not found in registry.");
                    }
                } else {
                     
                     
                     
                     
                    executorService = null;
                }
            }
            return executorService;
        } finally {
            lock.unlock();
        }
    }

    public <T> Set<T> findByType(Class<T> type) {
        Set<T> answer = new LinkedHashSet<>();
        try {
            NamingEnumeration<NameClassPair> list = getContext().list("");
            while (list.hasMore()) {
                NameClassPair pair = list.next();
                Object instance = context.lookup(pair.getName());
                instance = unwrap(instance);
                if (type.isInstance(instance)) {
                    answer.add(type.cast(instance));
                }
            }
        } catch (NamingException e) {
             
        }
        return answer;
    }

    protected Processor createBodyAndPropertyProcessor(final Object body, final String property, final Object propertyValue) {
        return new Processor() {
            public void process(Exchange exchange) {
                exchange.setProperty(property, propertyValue);
                Message in = exchange.getIn();
                in.setBody(body);
            }
        };
    }

    Consumer doCreateConsumer(
            CamelContext camelContext, Processor processor, String verb, String basePath, String uriTemplate,
            RestConfiguration configuration, Map<String, Object> parameters, boolean api)
            throws Exception {

        String path = basePath;
        if (uriTemplate != null) {
             
            if (uriTemplate.startsWith("/")) {
                path = path + uriTemplate;
            } else {
                path = path + "/" + uriTemplate;
            }
        }
        path = FileUtil.stripLeadingSeparator(path);

        String scheme = "http";
        String host = "";
        int port = 0;

         
        RestConfiguration config = configuration;
        if (config == null) {
            config = CamelContextHelper.getRestConfiguration(getCamelContext(), "jetty");
        }

        if (config.getScheme() != null) {
            scheme = config.getScheme();
        }
        if (config.getHost() != null) {
            host = config.getHost();
        }
        int num = config.getPort();
        if (num > 0) {
            port = num;
        }

         
        String contextPath = config.getContextPath();
        if (ObjectHelper.isNotEmpty(contextPath)) {
            contextPath = FileUtil.stripTrailingSeparator(contextPath);
            contextPath = FileUtil.stripLeadingSeparator(contextPath);
            if (ObjectHelper.isNotEmpty(contextPath)) {
                path = contextPath + "/" + path;
            }
        }

         
        if (ObjectHelper.isEmpty(host)) {
            host = RestComponentHelper.resolveRestHostName(host, config);
        }

        Map<String, Object> map = RestComponentHelper.initRestEndpointProperties("jetty", config);

        boolean cors = config.isEnableCORS();
        if (cors) {
             
            map.put("optionsEnabled", "true");
        }

        if (api) {
            map.put("matchOnUriPrefix", "true");
        }

        RestComponentHelper.addHttpRestrictParam(map, verb, cors);

        String url = RestComponentHelper.createRestConsumerUrl("jetty", scheme, host, port, path, map);

        JettyHttpEndpoint endpoint = (JettyHttpEndpoint) camelContext.getEndpoint(url, parameters);

        boolean binding = map.containsKey("httpBindingRef") || map.containsKey("httpBinding");

        if (!binding) {
             
            endpoint.setHttpBinding(new JettyRestHttpBinding(endpoint));
             
            endpoint.setEnableMultipartFilter(false);
        }

         
        Consumer consumer = endpoint.createConsumer(processor);
        if (config.getConsumerProperties() != null && !config.getConsumerProperties().isEmpty()) {
            setProperties(camelContext, consumer, config.getConsumerProperties());
        }

         
        ServiceHelper.startService(endpoint);

        return consumer;
    }

    public static Object deserializeJavaObjectFromStream(InputStream is, CamelContext context)
            throws ClassNotFoundException, IOException {
        if (is == null) {
            return null;
        }

        Object answer;
        ObjectInputStream ois = new CamelObjectInputStream(is, context);
        try {
            answer = ois.readObject();
        } finally {
            IOHelper.close(ois);
        }

        return answer;
    }

    public boolean matches(Exchange exchange) {
        final Object value = evaluate(exchange, Object.class);

        if (value instanceof BooleanNode) {
            return ((BooleanNode) value).asBoolean();
        }
        if (value instanceof Collection) {
            return !((Collection<?>) value).isEmpty();
        }

        return false;
    }

    private void updateGroup(Exchange exchange, ClientConfigurations clientConfigurations) {
         
        Object body = exchange.getMessage().getBody();
        KeystoneUpdateGroupOption groupOption;
        if (body instanceof KeystoneUpdateGroupOption) {
            groupOption = (KeystoneUpdateGroupOption) body;
        } else if (body instanceof String) {
            String strBody = (String) body;
            try {
                groupOption = new ObjectMapper().readValue(strBody, KeystoneUpdateGroupOption.class);
            } catch (JsonProcessingException e) {
                throw new IllegalArgumentException("String request body must be a valid JSON with the proper keys");
            }
        } else {
            throw new IllegalArgumentException(
                    "Exchange body is mandatory and should be a valid JSON string or KeystoneUpdateGroupOption object");
        }

         
        if (ObjectHelper.isEmpty(clientConfigurations.getGroupId())) {
            if (LOG.isErrorEnabled()) {
                LOG.error("No group id given");
            }
            throw new IllegalArgumentException("Group id is mandatory to update group");
        }

         
        KeystoneUpdateGroupRequestBody requestBody = new KeystoneUpdateGroupRequestBody()
                .withGroup(groupOption);
        KeystoneUpdateGroupRequest request = new KeystoneUpdateGroupRequest()
                .withBody(requestBody)
                .withGroupId(clientConfigurations.getGroupId());
        KeystoneUpdateGroupResponse response = iamClient.keystoneUpdateGroup(request);
        exchange.getMessage().setBody(gson.toJson(response.getGroup()));
    }

    private static boolean isJobOperation(OperationName operationName) {
        switch (operationName) {
            case COMPLETE_JOB:
            case FAIL_JOB:
            case UPDATE_JOB_RETRIES:
            case THROW_ERROR:
                return true;
            default:
                return false;
        }
    }

    public static MultipartSignedEntity parseMultipartSignedEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            String micalg,
            String charsetName,
            String contentTransferEncoding)
            throws ParseException {
        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {

            if (charsetName == null) {
                charsetName = StandardCharsets.US_ASCII.name();
            }
            Charset charset = Charset.forName(charsetName);
            CharsetDecoder charsetDecoder = charset.newDecoder();

            inbuffer.setCharsetDecoder(charsetDecoder);

            NameValuePair[] parameters = new NameValuePair[] {
                    new BasicNameValuePair("protocol", AS2MimeType.APPLICATION_PKCS7_SIGNATURE),
                    new BasicNameValuePair("boundary", boundary), new BasicNameValuePair("micalg", micalg),
                    new BasicNameValuePair("charset", charsetName) };
            ContentType contentType = ContentType.create(AS2MimeType.MULTIPART_SIGNED, parameters);
             
             
            MultipartSignedEntity multipartSignedEntity
                    = new MultipartSignedEntity(contentType, contentTransferEncoding, boundary, false);  

             
            skipPreambleAndStartBoundary(inbuffer, is, boundary);

             
             
             

             
            Header[] headers = AbstractMessageParser.parseHeaders(inbuffer, is, -1, -1, BasicLineParser.INSTANCE,
                    new ArrayList<>());

             
            ContentType signedEntityContentType = null;
            String signedEntityContentTransferEncoding = null;
            for (Header header : headers) {
                if (header.getName().equalsIgnoreCase(AS2Header.CONTENT_TYPE)) {
                    signedEntityContentType = ContentType.parse(header.getValue());
                } else if (header.getName().equalsIgnoreCase(AS2Header.CONTENT_TRANSFER_ENCODING)) {
                    signedEntityContentTransferEncoding = header.getValue();
                }
            }
            if (signedEntityContentType == null) {
                throw new HttpException("Failed to find Content-Type header in signed entity body part");
            }

            MimeEntity signedEntity = parseEntityBody(inbuffer, is, boundary, signedEntityContentType,
                    signedEntityContentTransferEncoding, "", headers);
            signedEntity.removeAllHeaders();
            signedEntity.setHeaders(headers);
            multipartSignedEntity.addPart(signedEntity);

             
             

             
             
             

             
            headers = AbstractMessageParser.parseHeaders(inbuffer, is, -1, -1, BasicLineParser.INSTANCE,
                    new ArrayList<>());

             
            ContentType signatureContentType = null;
            String signatureContentTransferEncoding = null;
            for (Header header : headers) {
                if (header.getName().equalsIgnoreCase(AS2Header.CONTENT_TYPE)) {
                    signatureContentType = ContentType.parse(header.getValue());
                } else if (header.getName().equalsIgnoreCase(AS2Header.CONTENT_TRANSFER_ENCODING)) {
                    signatureContentTransferEncoding = header.getValue();
                }
            }
            if (signatureContentType == null) {
                throw new HttpException("Failed to find Content-Type header in signature body part");
            }
            if (!ContentTypeUtils.isPkcs7SignatureType(signatureContentType)) {
                throw new HttpException(
                        "Invalid content type '" + signatureContentType.getMimeType() + "' for signature body part");
            }

            ApplicationPkcs7SignatureEntity applicationPkcs7SignatureEntity = parseApplicationPkcs7SignatureEntityBody(inbuffer,
                    is, boundary, signatureContentType, signatureContentTransferEncoding);
            applicationPkcs7SignatureEntity.removeAllHeaders();
            applicationPkcs7SignatureEntity.setHeaders(headers);
            multipartSignedEntity.addPart(applicationPkcs7SignatureEntity);

             
             

            return multipartSignedEntity;

        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse text entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }
    }

    protected AbstractMessageListenerContainer createListenerContainer() throws Exception {
        if (endpoint.getConfiguration().getReplyToConsumerType() == ConsumerType.Default) {
            return createDefaultListenerContainer();
        } else if (endpoint.getConfiguration().getReplyToConsumerType() == ConsumerType.Simple) {
            return createSimpleListenerContainer();
        } else {
            return getAbstractMessageListenerContainer(endpoint);
        }
    }

    private CamelLogger resolveLogger(DeadLetterChannelDefinition definition) {
        CamelLogger answer = definition.getLoggerBean();
        if (answer == null && definition.getLoggerRef() != null) {
            answer = mandatoryLookup(definition.getLoggerRef(), CamelLogger.class);
        }
        if (answer == null) {
            answer = new CamelLogger(LoggerFactory.getLogger(DeadLetterChannel.class), LoggingLevel.ERROR);
        }
        if (definition.getLevel() != null) {
            answer.setLevel(parse(LoggingLevel.class, definition.getLevel()));
        }
        return answer;
    }

    private FTPFile[] getFtpFilesFast(GenericFileOperations<FTPFile> operations, GenericFile<FTPFile> file) {
        String path = file.getAbsoluteFilePath();
        if (path.equals("/") || path.equals("\\")) {
             
            LOG.trace("Using fast exists to update file information in home directory");
            return operations.listFiles();
        } else {
            LOG.trace("Using fast exists to update file information for {}", path);
            return operations.listFiles(path);
        }
    }

    private void parseQueryParams(Map<String, Object> options) {
         
        final Map<String, String> queryParams = new HashMap<>();
        for (Iterator<Map.Entry<String, Object>> it = options.entrySet().iterator(); it.hasNext();) {

            final Map.Entry<String, Object> entry = it.next();
            final String paramName = entry.getKey();

             
            if (paramName.startsWith("consumer.")) {
                continue;
            }

            if (!olingo4endpointPropertyNames.contains(paramName)) {

                 
                final Object value = entry.getValue();
                if (value == null) {
                    throw new IllegalArgumentException("Null value for query parameter " + paramName);
                }
                queryParams.put(paramName, value.toString());

                 
                it.remove();
            }
        }
        if (!queryParams.isEmpty()) {

            @SuppressWarnings("unchecked")
            final Map<String, String> oldParams = (Map<String, String>) options.get(QUERY_PARAMS_PROPERTY);
            if (oldParams == null) {
                 
                options.put(QUERY_PARAMS_PROPERTY, queryParams);
            } else {
                 
                oldParams.putAll(queryParams);
            }

        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        getCurrentSagaCoordinator(exchange).whenComplete((coordinator, ex) -> ifNotException(ex, exchange, callback, () -> {
            if (coordinator == null) {
                exchange.setException(new CamelExchangeException("Exchange is not part of a saga", exchange));
                callback.done(false);
            } else {
                coordinator.beginStep(exchange, step)
                        .whenComplete((done, ex2) -> ifNotException(ex2, exchange, callback, () -> {
                            super.process(exchange, doneSync -> callback.done(false));
                        }));
            }
        }));
        return false;
    }

    private static void parseApplicationPkcs7MimeCompressedEntity(
            HttpMessage message, InputStream is, AS2SessionInputBuffer inBuffer, ContentType contentType,
            String contentTransferEncoding)
            throws HttpException {
        ApplicationPkcs7MimeCompressedDataEntity applicationPkcs7MimeCompressedDataEntity = null;

        ObjectHelper.notNull(message, "message");
        ObjectHelper.notNull(inBuffer, "inBuffer");

        HttpEntity entity = ObjectHelper.notNull(EntityUtils.getMessageEntity(message), "message entity");

        if (entity instanceof ApplicationPkcs7MimeCompressedDataEntity) {
             
            return;
        }

        Args.check(entity.isStreaming(), "Message entity can not be parsed: entity is not streaming");

        try {

            applicationPkcs7MimeCompressedDataEntity
                    = parseApplicationPkcs7MimeCompressedDataEntityBody(inBuffer, is, null, contentType,
                            contentTransferEncoding);
            applicationPkcs7MimeCompressedDataEntity.setMainBody(true);

            EntityUtils.setMessageEntity(message, applicationPkcs7MimeCompressedDataEntity);

        } catch (Exception e) {
            throw new HttpException("Failed to parse entity content", e);
        }
    }

    public void index(Object result) {
        if (result instanceof ClientEntitySet) {
            index((ClientEntitySet) result);
        } else if (result instanceof Iterable) {
            index((Iterable<?>) result);
        } else {
            indexDefault(result);
        }
    }

    public static void log(Logger log, LoggingLevel level, Marker marker, String message) {
        switch (level) {
            case DEBUG:
                log.debug(marker, message);
                break;
            case ERROR:
                log.error(marker, message);
                break;
            case INFO:
                log.info(marker, message);
                break;
            case TRACE:
                log.trace(marker, message);
                break;
            case WARN:
                log.warn(marker, message);
                break;
            default:
        }
    }

    protected final ClassLoader getProjectClassLoader() {
        if (projectClassLoader == null) {
            try {
                projectClassLoader = DynamicClassLoader.createDynamicClassLoader(project.getCompileClasspathElements());
            } catch (DependencyResolutionRequiredException e) {
                throw new RuntimeException("Unable to create project classloader", e);
            }
        }
        return projectClassLoader;
    }

    public void process(Exchange exchange) {
        if (exchange.getIn().getBody() instanceof int[]) {
            int[] seed = exchange.getIn().getBody(int[].class);
            Image[] result = predict(exchange, seed);
            exchange.getIn().setBody(result);
        } else {
            throw new RuntimeCamelException("Data type is not supported. Body should be int[]");
        }
    }

    public Set<Class<?>> findImplementations(Class<?> parent, String... packageNames) {
        if (packageNames == null) {
            return Collections.emptySet();
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Searching for implementations of {} in packages: {}", parent.getName(), Arrays.asList(packageNames));
        }

        PackageScanFilter test = getCompositeFilter(new AssignableToPackageScanFilter(parent));
        Set<Class<?>> classes = new LinkedHashSet<>();
        for (String pkg : packageNames) {
            find(test, pkg, classes);
        }

        LOG.debug("Found: {}", classes);

        return classes;
    }

        public void onPart(String channel, IRCUser user, String msg) {
            if (configuration.isOnPart()) {
                Exchange exchange = createOnPartExchange(channel, user, msg);
                try {
                    getProcessor().process(exchange);
                } catch (Exception e) {
                    handleException(e);
                }
            }
        }

    private Region messageToRegion(Message message) {
        Region region = message.getBody(Region.class);
        if (region == null) {
            Map headers = message.getHeaders();
            RegionBuilder builder = Builders.region();

            if (headers.containsKey(KeystoneConstants.DESCRIPTION)) {
                builder.description(message.getHeader(KeystoneConstants.DESCRIPTION, String.class));
            }

            region = builder.build();
        }

        return region;
    }

    protected boolean isCausedByRollbackExchangeException(Throwable exception) {
        if (exception == null) {
            return false;
        }
        if (exception instanceof RollbackExchangeException) {
            return true;
        } else if (exception.getCause() != null) {
             
            return isCausedByRollbackExchangeException(exception.getCause());
        }

        return false;
    }

    public InputStream resource(String path, Object resource, Map<String, Object> queryParams) {
        DeleteOperation deleteOperation = dhis2Client.delete(path);
        if (queryParams != null) {
            for (Map.Entry<String, Object> queryParam : queryParams.entrySet()) {
                if (queryParam.getValue() instanceof List) {
                    for (String queryValue : (List<String>) queryParam.getValue()) {
                        deleteOperation.withParameter(queryParam.getKey(), queryValue);
                    }
                } else {
                    deleteOperation.withParameter(queryParam.getKey(), (String) queryParam.getValue());
                }
            }
        }

        if (resource != null) {
            deleteOperation.withResource(resource);
        }

        return deleteOperation.transfer().read();

    }

    public ZipIterator(Exchange exchange, InputStream inputStream) {
        this.exchange = exchange;
        this.allowEmptyDirectory = false;

        Objects.requireNonNull(inputStream);

        if (inputStream instanceof ZipArchiveInputStream) {
            zipInputStream = (ZipArchiveInputStream) inputStream;
        } else {
            try {
                ArchiveInputStream input = new ArchiveStreamFactory().createArchiveInputStream(ArchiveStreamFactory.ZIP,
                        new BufferedInputStream(inputStream));
                zipInputStream = (ZipArchiveInputStream) input;
            } catch (ArchiveException e) {
                throw new RuntimeException(e.getMessage(), e);
            }
        }
        parent = null;
        first = true;
    }

    public Exchange createCopy(Exchange exchange) {
        Exchange answer = pool.poll();
        if (answer == null) {
            if (statisticsEnabled) {
                statistics.created.increment();
            }
             
            answer = new DefaultPooledExchange(exchange);
        } else {
            if (statisticsEnabled) {
                statistics.acquired.increment();
            }
        }

         
        ((ResetableClock) exchange.getClock()).reset();
        ExchangeHelper.copyResults(answer, exchange);
        return answer;
    }

    public Byte getByte(final String key) {
        Object returnable = this.get(key);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).byteValue();
    }

    public WatchEvent.Kind<Path> kind() {
        switch (this) {
            case CREATE:
                return StandardWatchEventKinds.ENTRY_CREATE;
            case MODIFY:
                return StandardWatchEventKinds.ENTRY_MODIFY;
            case DELETE:
                return StandardWatchEventKinds.ENTRY_DELETE;
            default:
                return null;
        }
    }

    protected RouteConfigurationDefinition createRouteConfiguration(String id) {
        RouteConfigurationDefinition config = new RouteConfigurationDefinition();
        if (id != null) {
            config.setId(id);
        }
        if (resource != null) {
            config.setResource(resource);
        }
        CamelContextAware.trySetCamelContext(config, camelContext);
        return config;
    }

    protected void doRemoteList(Exchange exchange, String operation) throws GitAPIException {
        List<RemoteConfig> result = null;

        try {
            result = git.remoteList().call();
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
        updateExchange(exchange, result);
    }

    protected void postProcessFactoryParameters(CamelContext camelContext, Map<String, Object> parameters) throws Exception {
        List<String> servers = List.class.cast(parameters.get("servers"));

        if (ObjectHelper.isNotEmpty(servers)) {
            final ListIterator<String> it = servers.listIterator();
            while (it.hasNext()) {
                it.set(camelContext.resolvePropertyPlaceholders(it.next()));
            }

            parameters.put("servers", servers);
        }
    }

        public void fromAdmin(Message message, SessionID sessionID)
                throws FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon {
            try {
                dispatch(QuickfixjEventCategory.AdminMessageReceived, sessionID, message);
            } catch (RuntimeException e) {
                throw e;
            } catch (Exception e) {
                rethrowIfType(e, FieldNotFound.class);
                rethrowIfType(e, IncorrectDataFormat.class);
                rethrowIfType(e, IncorrectTagValue.class);
                rethrowIfType(e, RejectLogon.class);
                throw new DispatcherException(e);
            }
        }

    private ContainerDiffCmd executeDiffContainerRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Diff Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);

        ObjectHelper.notNull(containerId, MISSING_CONTAINER_ID);

        ContainerDiffCmd diffContainerCmd = client.containerDiffCmd(containerId);

        String containerIdDiff
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID_DIFF, configuration, message, String.class);

        if (containerIdDiff != null) {
            diffContainerCmd.withContainerId(containerIdDiff);
        }

        return diffContainerCmd;

    }

    Consumer doCreateConsumer(
            CamelContext camelContext, Processor processor, String verb, String basePath, String uriTemplate,
            RestConfiguration configuration, Map<String, Object> parameters, boolean api)
            throws Exception {

        String path = basePath;
        if (uriTemplate != null) {
             
            if (uriTemplate.startsWith("/")) {
                path = path + uriTemplate;
            } else {
                path = path + "/" + uriTemplate;
            }
        }
        path = FileUtil.stripLeadingSeparator(path);

        String scheme = "http";
        String host = "";
        int port = 0;

         
        RestConfiguration config = configuration;
        if (config == null) {
            config = CamelContextHelper.getRestConfiguration(getCamelContext(), "netty-http");
        }
        if (config.getScheme() != null) {
            scheme = config.getScheme();
        }
        if (config.getHost() != null) {
            host = config.getHost();
        }
        int num = config.getPort();
        if (num > 0) {
            port = num;
        }

         
        String contextPath = config.getContextPath();
        if (ObjectHelper.isNotEmpty(contextPath)) {
            contextPath = FileUtil.stripTrailingSeparator(contextPath);
            contextPath = FileUtil.stripLeadingSeparator(contextPath);
            if (ObjectHelper.isNotEmpty(contextPath)) {
                path = contextPath + "/" + path;
            }
        }

         
        if (ObjectHelper.isEmpty(host)) {
            host = RestComponentHelper.resolveRestHostName(host, config);
        }

        Map<String, Object> map = RestComponentHelper.initRestEndpointProperties("netty-http", config);

         
        boolean cors = config.isEnableCORS();

        if (api) {
            map.put("matchOnUriPrefix", "true");
        }

        RestComponentHelper.addHttpRestrictParam(map, verb, cors);

        String url = RestComponentHelper.createRestConsumerUrl("netty-http", scheme, host, port, path, map);

        NettyHttpEndpoint endpoint = (NettyHttpEndpoint) camelContext.getEndpoint(url, parameters);

         
        Consumer consumer = endpoint.createConsumer(processor);
        if (config.getConsumerProperties() != null && !config.getConsumerProperties().isEmpty()) {
            setProperties(camelContext, consumer, config.getConsumerProperties());
        }

        return consumer;
    }

    public SchedulerFactory getSchedulerFactory() {
        if (schedulerFactory == null) {
            try {
                schedulerFactory = createSchedulerFactory();
            } catch (SchedulerException e) {
                throw new RuntimeException(e);
            }
        }
        return schedulerFactory;
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((DebeziumMongodbComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "bridgeErrorHandler": ((DebeziumMongodbComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "configuration": ((DebeziumMongodbComponent) component).setConfiguration((org.apache.camel.component.debezium.mongodb.configuration.MongoDbConnectorEmbeddedDebeziumConfiguration) value); return true;
            case "internalKeyConverter": getOrCreateConfiguration((DebeziumMongodbComponent) component).setInternalKeyConverter((java.lang.String) value); return true;
            case "internalValueConverter": getOrCreateConfiguration((DebeziumMongodbComponent) component).setInternalValueConverter((java.lang.String) value); return true;
            case "offsetCommitPolicy": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetCommitPolicy((java.lang.String) value); return true;
            case "offsetCommitTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetCommitTimeoutMs((long) value); return true;
            case "offsetFlushIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetFlushIntervalMs((long) value); return true;
            case "offsetStorage": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorage((java.lang.String) value); return true;
            case "offsetStorageFileName": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorageFileName((java.lang.String) value); return true;
            case "offsetStoragePartitions": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStoragePartitions((int) value); return true;
            case "offsetStorageReplicationFactor": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorageReplicationFactor((int) value); return true;
            case "offsetStorageTopic": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorageTopic((java.lang.String) value); return true;
            case "autowiredEnabled": ((DebeziumMongodbComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "captureMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCaptureMode((java.lang.String) value); return true;
            case "collectionExcludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCollectionExcludeList((java.lang.String) value); return true;
            case "collectionIncludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCollectionIncludeList((java.lang.String) value); return true;
            case "connectionValidationTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setConnectionValidationTimeoutMs((long) value); return true;
            case "converters": getOrCreateConfiguration((DebeziumMongodbComponent) component).setConverters((java.lang.String) value); return true;
            case "cursorMaxAwaitTimeMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCursorMaxAwaitTimeMs((int) value); return true;
            case "customMetricTags": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCustomMetricTags((java.lang.String) value); return true;
            case "customSanitizePattern": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCustomSanitizePattern((java.lang.String) value); return true;
            case "databaseExcludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setDatabaseExcludeList((java.lang.String) value); return true;
            case "databaseIncludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setDatabaseIncludeList((java.lang.String) value); return true;
            case "errorsMaxRetries": getOrCreateConfiguration((DebeziumMongodbComponent) component).setErrorsMaxRetries((int) value); return true;
            case "eventProcessingFailureHandlingMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setEventProcessingFailureHandlingMode((java.lang.String) value); return true;
            case "executorShutdownTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setExecutorShutdownTimeoutMs((long) value); return true;
            case "extendedHeadersEnabled": getOrCreateConfiguration((DebeziumMongodbComponent) component).setExtendedHeadersEnabled((boolean) value); return true;
            case "fieldExcludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setFieldExcludeList((java.lang.String) value); return true;
            case "fieldRenames": getOrCreateConfiguration((DebeziumMongodbComponent) component).setFieldRenames((java.lang.String) value); return true;
            case "guardrailCollectionsLimitAction": getOrCreateConfiguration((DebeziumMongodbComponent) component).setGuardrailCollectionsLimitAction((java.lang.String) value); return true;
            case "guardrailCollectionsMax": getOrCreateConfiguration((DebeziumMongodbComponent) component).setGuardrailCollectionsMax((int) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setHeartbeatIntervalMs((int) value); return true;
            case "heartbeatTopicsPrefix": getOrCreateConfiguration((DebeziumMongodbComponent) component).setHeartbeatTopicsPrefix((java.lang.String) value); return true;
            case "incrementalSnapshotWatermarkingStrategy": getOrCreateConfiguration((DebeziumMongodbComponent) component).setIncrementalSnapshotWatermarkingStrategy((java.lang.String) value); return true;
            case "maxBatchSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMaxBatchSize((int) value); return true;
            case "maxQueueSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMaxQueueSize((int) value); return true;
            case "maxQueueSizeInBytes": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMaxQueueSizeInBytes((long) value); return true;
            case "mongodbAuthsource": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbAuthsource((java.lang.String) value); return true;
            case "mongodbConnectionString": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbConnectionString((java.lang.String) value); return true;
            case "mongodbConnectTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbConnectTimeoutMs((int) value); return true;
            case "mongodbHeartbeatFrequencyMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbHeartbeatFrequencyMs((int) value); return true;
            case "mongodbPassword": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbPassword((java.lang.String) value); return true;
            case "mongodbPollIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbPollIntervalMs((long) value); return true;
            case "mongodbServerSelectionTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbServerSelectionTimeoutMs((int) value); return true;
            case "mongodbSocketTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbSocketTimeoutMs((int) value); return true;
            case "mongodbSslEnabled": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbSslEnabled((boolean) value); return true;
            case "mongodbSslInvalidHostnameAllowed": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbSslInvalidHostnameAllowed((boolean) value); return true;
            case "mongodbUser": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbUser((java.lang.String) value); return true;
            case "notificationEnabledChannels": getOrCreateConfiguration((DebeziumMongodbComponent) component).setNotificationEnabledChannels((java.lang.String) value); return true;
            case "notificationSinkTopicName": getOrCreateConfiguration((DebeziumMongodbComponent) component).setNotificationSinkTopicName((java.lang.String) value); return true;
            case "openlineageIntegrationConfigFilePath": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationConfigFilePath((java.lang.String) value); return true;
            case "openlineageIntegrationDatasetKafkaBootstrapServers": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationDatasetKafkaBootstrapServers((java.lang.String) value); return true;
            case "openlineageIntegrationEnabled": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationEnabled((boolean) value); return true;
            case "openlineageIntegrationJobDescription": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobDescription((java.lang.String) value); return true;
            case "openlineageIntegrationJobNamespace": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobNamespace((java.lang.String) value); return true;
            case "openlineageIntegrationJobOwners": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobOwners((java.lang.String) value); return true;
            case "openlineageIntegrationJobTags": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobTags((java.lang.String) value); return true;
            case "pollIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setPollIntervalMs((long) value); return true;
            case "postProcessors": getOrCreateConfiguration((DebeziumMongodbComponent) component).setPostProcessors((java.lang.String) value); return true;
            case "provideTransactionMetadata": getOrCreateConfiguration((DebeziumMongodbComponent) component).setProvideTransactionMetadata((boolean) value); return true;
            case "queryFetchSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setQueryFetchSize((int) value); return true;
            case "retriableRestartConnectorWaitMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setRetriableRestartConnectorWaitMs((long) value); return true;
            case "schemaHistoryInternalFileFilename": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSchemaHistoryInternalFileFilename((java.lang.String) value); return true;
            case "schemaNameAdjustmentMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSchemaNameAdjustmentMode((java.lang.String) value); return true;
            case "signalDataCollection": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSignalDataCollection((java.lang.String) value); return true;
            case "signalEnabledChannels": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSignalEnabledChannels((java.lang.String) value); return true;
            case "signalPollIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSignalPollIntervalMs((long) value); return true;
            case "skippedOperations": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSkippedOperations((java.lang.String) value); return true;
            case "snapshotCollectionFilterOverrides": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotCollectionFilterOverrides((java.lang.String) value); return true;
            case "snapshotDelayMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotDelayMs((long) value); return true;
            case "snapshotFetchSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotFetchSize((int) value); return true;
            case "snapshotIncludeCollectionList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotIncludeCollectionList((java.lang.String) value); return true;
            case "snapshotMaxThreads": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotMaxThreads((int) value); return true;
            case "snapshotMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotMode((java.lang.String) value); return true;
            case "snapshotModeConfigurationBasedSnapshotData": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotData((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnDataError": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotOnDataError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnSchemaError": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotOnSchemaError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotSchema": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotSchema((boolean) value); return true;
            case "snapshotModeConfigurationBasedStartStream": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedStartStream((boolean) value); return true;
            case "snapshotModeCustomName": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeCustomName((java.lang.String) value); return true;
            case "sourceinfoStructMaker": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSourceinfoStructMaker((java.lang.String) value); return true;
            case "streamingDelayMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setStreamingDelayMs((long) value); return true;
            case "tombstonesOnDelete": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTombstonesOnDelete((boolean) value); return true;
            case "topicNamingStrategy": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTopicNamingStrategy((java.lang.String) value); return true;
            case "topicPrefix": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTopicPrefix((java.lang.String) value); return true;
            case "transactionMetadataFactory": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTransactionMetadataFactory((java.lang.String) value); return true;
            default: return false;
            }
        }

    private String getContent(Row r) {
        StringJoiner sj = new StringJoiner("   ");
        if (r.consumes != null || r.produces != null) {
            if (r.consumes != null) {
                sj.add("accept: " + r.consumes);
            }
            if (r.produces != null) {
                sj.add("produces: " + r.produces);
            }
        }
        if (sj.length() > 0) {
            return sj.toString();
        }
        return "";
    }

    public void pre(Entity segment, Exchange exchange, Endpoint endpoint) {
        super.pre(segment, exchange, endpoint);

        String partition = (String) exchange.getIn().getHeader(PARTITION);
        if (partition != null) {
            segment.putMetadata(KAFKA_PARTITION_TAG, partition);
        }

        String partitionKey = (String) exchange.getIn().getHeader(PARTITION_KEY);
        if (partitionKey != null) {
            segment.putMetadata(KAFKA_PARTITION_KEY_TAG, partitionKey);
        }

        String key = (String) exchange.getIn().getHeader(KEY);
        if (key != null) {
            segment.putMetadata(KAFKA_KEY_TAG, key);
        }

        String offset = (String) exchange.getIn().getHeader(OFFSET);
        if (offset != null) {
            segment.putMetadata(KAFKA_OFFSET_TAG, offset);
        }
    }

    private void processGetAllQueryJobs(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        String queryLocator = getParameter(QUERY_LOCATOR, exchange, IGNORE_BODY, IS_OPTIONAL);
        bulkClient.getAllQueryJobs(queryLocator, determineHeaders(exchange),
                new BulkApiV2Client.QueryJobsResponseCallback() {
                    @Override
                    public void onResponse(QueryJobs jobs, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, jobs, headers, ex, callback);
                    }
                });
    }

    public MailConfiguration copy() {
        try {
            MailConfiguration copy = (MailConfiguration) clone();
             
            copy.recipients = new HashMap<>();
            copy.recipients.putAll(this.recipients);
            return copy;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeCamelException(e);
        }
    }

    public String dumpStatisticsAsJson() {
        ObjectWriter writer = mapper.writer();
        if (isPrettyPrint()) {
            writer = writer.withDefaultPrettyPrinter();
        }
        try {
            return writer.writeValueAsString(getMetricsRegistry());
        } catch (JsonProcessingException e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    protected Expression createExpression(String uri) {
         
        uri = EndpointHelper.resolveEndpointUriPropertyPlaceholders(camelContext, uri);

         
        String language = null;
        if (uri.startsWith("language:")) {
            String value = StringHelper.after(uri, "language:");
            language = StringHelper.before(value, ":");
            uri = StringHelper.after(value, ":");
        }
        if (language == null) {
             
            language = LanguageSupport.hasSimpleFunction(uri) ? "simple" : "constant";
        }
        Language lan = camelContext.resolveLanguage(language);
        return lan.createExpression(uri);
    }

    Attributes convertToAttributes(Map<String, ?> fields) {
        AttributesBuilder attributesBuilder = Attributes.builder();

        for (Map.Entry<String, ?> entry : fields.entrySet()) {
            String key = entry.getKey();
            Object value = entry.getValue();
            if (value == null) {
                continue;
            }
            if (value instanceof Byte
                    || value instanceof Short
                    || value instanceof Integer
                    || value instanceof Long) {
                attributesBuilder.put(key, ((Number) value).longValue());
            } else if (value instanceof Float || value instanceof Double) {
                attributesBuilder.put(key, ((Number) value).doubleValue());
            } else if (value instanceof Boolean) {
                attributesBuilder.put(key, (Boolean) value);
            } else {
                attributesBuilder.put(key, value.toString());
            }
        }
        return attributesBuilder.build();
    }

    private void detachVolumeToDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
        String volumeId = exchange.getIn().getHeader(DigitalOceanHeaders.ID, String.class);
        String volumeName = exchange.getIn().getHeader(DigitalOceanHeaders.VOLUME_NAME, String.class);
        Integer dropletId = exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_ID, Integer.class);
        String region = exchange.getIn().getHeader(DigitalOceanHeaders.REGION, String.class);

        if (ObjectHelper.isEmpty(dropletId)) {
            throw new IllegalArgumentException(DigitalOceanHeaders.DROPLET_ID + " must be specified");
        }

        if (ObjectHelper.isEmpty(region)) {
            throw new IllegalArgumentException(DigitalOceanHeaders.REGION + " must be specified");
        }

        Action action;

        if (ObjectHelper.isNotEmpty(volumeName)) {
            action = getEndpoint().getDigitalOceanClient().detachVolumeByName(dropletId, volumeName, region);
            LOG.trace("Detach Volume {} to Droplet {} [{}] ", volumeName, dropletId, action);
        } else if (ObjectHelper.isNotEmpty(volumeId)) {
            action = getEndpoint().getDigitalOceanClient().detachVolume(dropletId, volumeId, region);
            LOG.trace("Detach Volume {} to Droplet {} [{}] ", volumeId, dropletId, action);
        } else {
            throw new IllegalArgumentException(
                    DigitalOceanHeaders.ID + " or " + DigitalOceanHeaders.VOLUME_NAME + " must be specified");
        }

        exchange.getMessage().setBody(action);

    }

    public void completedExchange(Exchange exchange, long time) {
         
         
         
         
        UnitOfWork uow = exchange.getUnitOfWork();
        if (uow != null) {
            int level = uow.routeStackLevel(includeRouteTemplates, includeKamelets);
            if (level <= 1) {
                super.completedExchange(exchange, time);
                if (exchange.getFromEndpoint() != null && exchange.getFromEndpoint().isRemote()) {
                    remoteExchangesTotal.increment();
                    remoteExchangesCompleted.increment();
                    remoteExchangesInflight.decrement();
                }
            }
        } else {
            super.completedExchange(exchange, time);
            if (exchange.getFromEndpoint() != null && exchange.getFromEndpoint().isRemote()) {
                remoteExchangesTotal.increment();
                remoteExchangesCompleted.increment();
                remoteExchangesInflight.decrement();
            }
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvents.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.azure.storage.queue.receiveMessages");

        if (message.getHeaders().containsKey(QueueConstants.MESSAGE_ID)) {
            headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SOURCE,
                    "azure.storage.queue." + message.getHeader(QueueConstants.MESSAGE_ID, String.class));
        }

        if (message.getHeaders().containsKey(QueueConstants.POP_RECEIPT)) {
            headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(QueueConstants.POP_RECEIPT, String.class));
        }
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvents.TEXT_PLAIN_MIME_TYPE);
    }

    public Exchange add(CamelContext camelContext, String key, Exchange exchange) {
        if (optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(), key);
        RLock lock = redisson.getLock("aggregationLock");
        try {
            lock.lock();
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(exchange, true, allowSerializedHeaders);
            DefaultExchangeHolder oldHolder = cache.put(key, newHolder);
            return unmarshallExchange(camelContext, oldHolder);
        } finally {
            LOG.trace("Added an Exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(), key);
            lock.unlock();
        }
    }

        protected void doProcess(String arg, LinkedList<String> remainingArgs) {
            if (remainingArgs.isEmpty()) {
                System.err.println("Expected fileName for ");
                showOptions();
                completed();
            } else {
                String parameter = remainingArgs.removeFirst();
                doProcess(arg, parameter, remainingArgs);
            }
        }

    public String browseRangeMessagesAsXml(Integer fromIndex, Integer toIndex, Boolean includeBody) {
        if (fromIndex == null) {
            fromIndex = 0;
        }
        if (toIndex == null) {
            toIndex = Integer.MAX_VALUE;
        }
        if (fromIndex > toIndex) {
            throw new IllegalArgumentException(
                    "From index cannot be larger than to index, was: " + fromIndex + " > " + toIndex);
        }

        List<Exchange> exchanges = getEndpoint().getExchanges();
        if (exchanges.isEmpty()) {
            return null;
        }

        StringBuilder sb = new StringBuilder();
        sb.append("<messages>");
        for (int i = fromIndex; i < exchanges.size() && i <= toIndex; i++) {
            Exchange exchange = exchanges.get(i);
            Message msg = exchange.getMessage();
            String xml = MessageHelper.dumpAsXml(msg, includeBody);
            sb.append("\n").append(xml);
        }
        sb.append("\n</messages>");
        return sb.toString();
    }

    private int doRunDebugQuarkus(KameletMain main) throws Exception {
        Path pom = Paths.get("pom.xml");
        MavenXpp3Reader mavenReader = new MavenXpp3Reader();
        try (Reader reader = Files.newBufferedReader(pom)) {
            Model model = mavenReader.read(reader);

             
            Dependency d = new Dependency();
            d.setGroupId("org.apache.camel.quarkus");
            d.setArtifactId("camel-quarkus-debug");
            model.getDependencies().add(d);
            d = new Dependency();
            d.setGroupId("org.apache.camel.quarkus");
            d.setArtifactId("camel-quarkus-cli-connector");
            model.getDependencies().add(d);

            Profile mp = new Profile();
            model.addProfile(mp);
            mp.setId("camel-debug");
            Activation a = new Activation();
            a.setActiveByDefault(true);
            mp.setActivation(a);

            Build b = new Build();
            mp.setBuild(b);

            Plugin pi = new Plugin();
            b.addPlugin(pi);
            pi.setGroupId(quarkusGroupId);
            pi.setArtifactId("quarkus-maven-plugin");
            pi.setVersion(quarkusVersion);
            PluginExecution pe = new PluginExecution();
            pe.addGoal("build");
            pi.addExecution(pe);
            Xpp3Dom cfg = new Xpp3Dom("finalName");
            cfg.setValue("camel-jbang-debug");
            Xpp3Dom root = new Xpp3Dom("configuration");
            root.addChild(cfg);
            pi.setConfiguration(root);

            MavenXpp3Writer w = new MavenXpp3Writer();
            FileOutputStream fos = new FileOutputStream("camel-jbang-debug-pom.xml", false);
            w.write(fos, model);
            IOHelper.close(fos);

            printer().println("Preparing Camel Quarkus for debugging ...");

             
            String mvnw = "/mvnw";
            if (FileUtil.isWindows()) {
                mvnw = "/mvnw.cmd";
            }
            if (!new File(mvnw).exists()) {
                mvnw = "mvn";
            }
             
            ProcessBuilder pb = new ProcessBuilder();
            pb.command(mvnw, "-Dmaven.test.skip", "--file", "camel-jbang-debug-pom.xml", "package", "quarkus:build");
            Process p = pb.start();

            if (p.waitFor(30, TimeUnit.SECONDS)) {
                AtomicReference<Process> processRef = new AtomicReference<>();
                Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                    try {
                         
                        Process process = processRef.get();
                        if (process != null) {
                            process.destroy();
                            for (int i = 0; i < 30; i++) {
                                if (!process.isAlive()) {
                                    break;
                                }
                                try {
                                    Thread.sleep(1000);
                                } catch (InterruptedException e) {
                                    Thread.currentThread().interrupt();
                                }
                            }
                        }
                        removeDir(Paths.get(RUN_PLATFORM_DIR));
                        removeDir(Paths.get(CAMEL_JBANG_WORK_DIR));
                        Files.deleteIfExists(Paths.get("camel-jbang-debug-pom.xml"));
                    } catch (Exception e) {
                         
                    }
                }));

                 
                pb = new ProcessBuilder();
                pb.command("java",
                        "-Dcamel.debug.enabled=true",
                        (breakpoint == null
                                ? "-Dcamel.debug.breakpoints=_all_routes_" : "-Dcamel.debug.breakpoints=" + breakpoint),
                        "-Dcamel.debug.loggingLevel=DEBUG",
                        "-Dcamel.debug.singleStepIncludeStartEnd=true",
                        "-Dcamel.main.sourceLocationEnabled=true",
                        "-jar", "target/quarkus-app/quarkus-run.jar");

                p = pb.start();
                processRef.set(p);
                this.spawnOutput = p.getInputStream();
                this.spawnError = p.getErrorStream();
                this.spawnPid = p.pid();
                printer().println("Debugging Camel Quarkus integration: " + name + " with PID: " + p.pid());
            } else {
                printer().printErr("Timed out preparing Camel Quarkus for debugging");
                this.spawnError = p.getErrorStream();
                this.spawnPid = p.pid();
                p.destroy();
                return -1;
            }
        }

        return 0;
    }

    private void executeComponent() throws MojoExecutionException {
         
        final String kind = "component";
        List<String> componentNames = listDescriptorNamesOfType(kind);

        final Set<File> jsonFiles = new TreeSet<>();
        PackageHelper.findJsonFiles(buildDir, jsonFiles);

         
        if (!componentNames.isEmpty()) {
            if (getLog().isDebugEnabled()) {
                getLog().debug("Found " + componentNames.size() + " components");
            }

            for (String componentName : componentNames) {
                String json = loadJsonFrom(jsonFiles, kind, componentName);
                if (json != null) {
                     
                    componentName = asComponentName(componentName);

                    File file = new File(componentDocDir, componentName + "-" + kind + ".adoc");
                    boolean exists = file.exists();

                    ComponentModel model = generateComponentModel(json);
                    String title = asComponentTitle(model.getScheme(), model.getTitle());
                    model.setTitle(title);

                    boolean updated = updateHeader(componentName, file, model, " Component");

                    checkComponentHeader(file);
                    checkSince(file);

                    String options = evaluateTemplate("component-options.mvel", model);
                    updated |= updateOptionsIn(file, kind, options);

                    if (updated) {
                        getLog().info("Updated doc file: " + file);
                    } else if (exists) {
                        if (getLog().isDebugEnabled()) {
                            getLog().debug("No changes to doc file: " + file);
                        }
                    } else {
                        getLog().warn("No component doc file: " + file);
                        if (isFailFast()) {
                            throw new MojoExecutionException("Failed build due failFast=true");
                        }
                    }
                }
            }
        }
    }

    private void doSetState(Exchange exchange, AsyncCallback callback) {
        Object body = exchange.getIn().getBody();
        if (ObjectHelper.isEmpty(body)) {
            exchange.setException(new CamelException("Can not publish empty message"));
            callback.done(true);
        }
        LOG.debug("Sending setState [{}] to channel [{}]", body, getChannel(exchange));
        endpoint.getPubnub()
                .setPresenceState()
                .channels(List.of(getChannel(exchange)))
                .state(body)
                .uuid(getUUID(exchange))
                .async((Result<PNSetStateResult> result) -> {
                    LOG.debug("Got setState response [{}]", result);
                    if (result.isFailure()) {
                        PubNubException ex = result.exceptionOrNull();
                        if (ex != null) {
                            exchange.setException(ex);
                        }
                        callback.done(false);
                    } else {
                        PNSetStateResult r = result.getOrNull();
                        processMessage(exchange, callback, r);
                    }
                });
    }

    void logUsageSummary(Logger log, String name, int pooled) {
        if (statisticsEnabled && consumer != null) {
             
            long created = statistics.getCreatedCounter();
            long acquired = statistics.getAcquiredCounter();
            long released = statistics.getReleasedCounter();
            long discarded = statistics.getDiscardedCounter();
            boolean shouldLog = pooled > 0 || created > 0 || acquired > 0 || released > 0 || discarded > 0;
            if (shouldLog) {
                String id = getRouteId();
                if (id == null) {
                    id = "";
                } else {
                    id = " " + id;
                }
                String uri = consumer.getEndpoint().getEndpointBaseUri();
                uri = URISupport.sanitizeUri(uri);

                 
                boolean leak = created + acquired > released + discarded;
                if (leak) {
                    long leaks = (created + acquired) - (released + discarded);
                    log.warn(
                            "{}{} ({}) usage (leaks detected: {}) [pooled: {}, created: {}, acquired: {}, released: {}, discarded: {}]",
                            name, id, uri, leaks, pooled, created, acquired, released, discarded);
                } else {
                    log.info("{}{} ({}) usage [pooled: {}, created: {}, acquired: {}, released: {}, discarded: {}]",
                            name, id, uri, pooled, created, acquired, released, discarded);
                }
            }
        }
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.twilio.type.Endpoint.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toPhoneNumber((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.twilio.type.Sip.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.twilio.TwilioConverter.toSip((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private SSLContext createSSLContext() throws Exception {
        if (!configuration.isSsl()) {
            return null;
        }

        SSLContext answer;

         
        if (configuration.getSslContextParameters() != null) {
            answer = configuration.getSslContextParameters().createSSLContext(null);
        } else {
            char[] pw = configuration.getPassphrase() != null ? configuration.getPassphrase().toCharArray() : null;

            SSLEngineFactory sslEngineFactory = new SSLEngineFactory();
            answer = sslEngineFactory.createSSLContext(camelContext,
                    configuration.getKeyStoreFormat(),
                    configuration.getSecurityProvider(),
                    configuration.getKeyStoreResource(),
                    configuration.getTrustStoreResource(),
                    pw);
        }

        return answer;
    }

    public BigDecimal getBigDecimal(final int index) {
        Object returnable = this.get(index);
        if (returnable instanceof BigDecimal) {
             
        } else if (returnable instanceof Number) {
             
            returnable = new BigDecimal(returnable.toString());
        } else if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return (BigDecimal) returnable;
    }

    public Processor createErrorHandler(Processor processor) throws Exception {
         
        TransactionTemplate transactionTemplate = resolveTransactionTemplate(definition);
        ObjectHelper.notNull(transactionTemplate, "transactionTemplate", this);

         
        RedeliveryPolicy redeliveryPolicy = resolveRedeliveryPolicy(definition, camelContext);
        CamelLogger logger = resolveLogger(definition);
        LoggingLevel rollbackLoggingLevel = resolveRollbackLoggingLevel(definition);

        TransactionErrorHandler answer = new TransactionErrorHandler(
                camelContext, processor, logger,
                getProcessor(definition.getOnRedeliveryProcessor(), definition.getOnRedeliveryRef()),
                redeliveryPolicy,
                transactionTemplate,
                resolveRetryWhilePolicy(definition, camelContext),
                getExecutorService(definition.getExecutorServiceBean(), definition.getExecutorServiceRef()),
                rollbackLoggingLevel,
                getProcessor(definition.getOnExceptionOccurredProcessor(), definition.getOnExceptionOccurredRef()));
         
        configure(answer);
        return answer;
    }

    public Exchange receiveNoWait(Endpoint endpoint) {
        if (camelContext.isStopped()) {
            throw new RejectedExecutionException(CONTEXT_IS_STOPPED);
        }

        LOG.debug("<<<< {}", endpoint);
        PollingConsumer consumer = null;
        try {
            consumer = acquirePollingConsumer(endpoint);
            return consumer.receiveNoWait();
        } finally {
            if (consumer != null) {
                releasePollingConsumer(endpoint, consumer);
            }
        }
    }

    protected void doResume() throws Exception {
         
        if (!initialized) {
            doStart();
        } else {
            if (listenerContainer != null) {
                startListenerContainer();
            } else {
                LOG.warn(
                        "The listenerContainer is not instantiated. Probably there was a timeout during the Suspend operation. Please restart your consumer route.");
            }
        }
    }

    private SslHandler configureServerSSLOnDemand() {
        if (!consumer.getConfiguration().isSsl()) {
            return null;
        }

        if (consumer.getConfiguration().getSslHandler() != null) {
            return consumer.getConfiguration().getSslHandler();
        } else if (sslContext != null) {
            SSLEngine engine = sslContext.createSSLEngine();
            engine.setUseClientMode(false);
            engine.setNeedClientAuth(consumer.getConfiguration().isNeedClientAuth());
            if (consumer.getConfiguration().isHostnameVerification()) {
                SSLParameters sslParams = engine.getSSLParameters();
                sslParams.setEndpointIdentificationAlgorithm("HTTPS");
                engine.setSSLParameters(sslParams);
            }
            if (consumer.getConfiguration().getSslContextParameters() == null) {
                 
                engine.setEnabledProtocols(consumer.getConfiguration().getEnabledProtocols().split(","));
            }
            return new SslHandler(engine);
        }

        return null;
    }

    private void doCreateOrUpdatePersistentVolumeClaim(
            Exchange exchange, String operationName,
            Function<Resource<PersistentVolumeClaim>, PersistentVolumeClaim> operation) {
        String pvcName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_PERSISTENT_VOLUME_CLAIM_NAME, String.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        PersistentVolumeClaimSpec pvcSpec = exchange.getIn()
                .getHeader(KubernetesConstants.KUBERNETES_PERSISTENT_VOLUME_CLAIM_SPEC, PersistentVolumeClaimSpec.class);
        if (ObjectHelper.isEmpty(pvcName)) {
            LOG.error("{} a specific Persistent Volume Claim require specify a Persistent Volume Claim name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Persistent Volume Claim require specify a Persistent Volume Claim name",
                            operationName));
        }
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific Persistent Volume Claim require specify a namespace name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Persistent Volume Claim require specify a namespace name", operationName));
        }
        if (ObjectHelper.isEmpty(pvcSpec)) {
            LOG.error("{} a specific Persistent Volume Claim require specify a Persistent Volume Claim spec bean",
                    operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Persistent Volume Claim require specify a Persistent Volume Claim spec bean",
                            operationName));
        }
        Map<String, String> labels
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_PERSISTENT_VOLUMES_CLAIMS_LABELS, Map.class);
        PersistentVolumeClaim pvcCreating = new PersistentVolumeClaimBuilder().withNewMetadata().withName(pvcName)
                .withLabels(labels).endMetadata().withSpec(pvcSpec).build();
        PersistentVolumeClaim pvc
                = operation.apply(getEndpoint().getKubernetesClient().persistentVolumeClaims().inNamespace(namespaceName)
                        .resource(pvcCreating));

        prepareOutboundMessage(exchange, pvc);
    }

    public void onRemove(Message message) {
        final BasicCache<Object, Object> cache = getCache(message);
        final Object key = message.getHeader(InfinispanConstants.KEY, configuration::getKey);
        final Object value = message.getHeader(InfinispanConstants.VALUE, configuration::getValue);
        final Object result;

        if (ObjectHelper.isEmpty(value)) {
            result = cache.remove(key);
        } else {
            result = cache.remove(key, value);
        }

        setResult(message, result);
    }

    SSLContext provideSSLContext() throws GeneralSecurityException, IOException {
        if (sslContextParameters != null) {
            return sslContextParameters.createSSLContext(getCamelContext());
        } else if (getComponent().getSslContextParameters() != null) {
            return getComponent().getSslContextParameters().createSSLContext(getCamelContext());
        } else {
            return null;
        }
    }

    public String extractCompletionReason(String chunk) throws JsonProcessingException {
        if (chunk == null || chunk.trim().isEmpty()) {
            return null;
        }
        JsonNode node = MAPPER.readTree(chunk);
        JsonNode outputs = node.get("outputs");
        if (outputs != null && outputs.isArray() && outputs.size() > 0) {
            JsonNode firstOutput = outputs.get(0);
            JsonNode stopReason = firstOutput.get("stop_reason");
            return stopReason != null && !stopReason.isNull() ? stopReason.asText() : null;
        }
        return null;
    }

    protected void doStart() throws Exception {
        if (maximumRedeliveries < 0) {
            throw new IllegalArgumentException("Maximum redelivery retries must be zero or a positive integer.");
        }
        if (recoveryInterval < 0) {
            throw new IllegalArgumentException("Recovery interval must be zero or a positive integer.");
        }

        if (cache == null) {
            ObjectHelper.notNull(cacheManager, "cacheManager");
            cache = cacheManager.getCache(cacheName, String.class, DefaultExchangeHolder.class);
        }
    }

    public <T> T evaluate(CamelContext context, Object body, Class<T> type) {
        ObjectHelper.notNull(context, "CamelContext");

         
        Exchange dummy = new DefaultExchange(context);
        dummy.getIn().setBody(body);

        try {
            return evaluate(dummy, type);
        } finally {
             
            exchange.remove();
        }
    }

        public AnnotationBuilder withDefaultValue(JsonNode node) {
            if (node == null) {
                return this;
            }
            if (node.isMissingNode()) {
                return this;
            }
            if (!node.isTextual() && !node.isNumber() && !node.isBoolean()) {
                return this;
            }

            return withDefaultValue(node.asText());
        }

        DateTimeFormatter getDateFormat() {
            DateTimeFormatter result;
            if (locale != null) {
                result = DateTimeFormatter.ofPattern(pattern, locale);
            } else {
                result = DateTimeFormatter.ofPattern(pattern);
            }
            return result;
        }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "bridgeErrorHandler": ((DebeziumSqlserverComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "configuration": ((DebeziumSqlserverComponent) component).setConfiguration((org.apache.camel.component.debezium.sqlserver.configuration.SqlServerConnectorEmbeddedDebeziumConfiguration) value); return true;
            case "internalKeyConverter": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setInternalKeyConverter((java.lang.String) value); return true;
            case "internalValueConverter": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setInternalValueConverter((java.lang.String) value); return true;
            case "offsetCommitPolicy": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetCommitPolicy((java.lang.String) value); return true;
            case "offsetCommitTimeoutMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetCommitTimeoutMs((long) value); return true;
            case "offsetFlushIntervalMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetFlushIntervalMs((long) value); return true;
            case "offsetStorage": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetStorage((java.lang.String) value); return true;
            case "offsetStorageFileName": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetStorageFileName((java.lang.String) value); return true;
            case "offsetStoragePartitions": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetStoragePartitions((int) value); return true;
            case "offsetStorageReplicationFactor": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetStorageReplicationFactor((int) value); return true;
            case "offsetStorageTopic": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetStorageTopic((java.lang.String) value); return true;
            case "autowiredEnabled": ((DebeziumSqlserverComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "binaryHandlingMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setBinaryHandlingMode((java.lang.String) value); return true;
            case "columnExcludeList": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setColumnExcludeList((java.lang.String) value); return true;
            case "columnIncludeList": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setColumnIncludeList((java.lang.String) value); return true;
            case "columnPropagateSourceType": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setColumnPropagateSourceType((java.lang.String) value); return true;
            case "connectionValidationTimeoutMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setConnectionValidationTimeoutMs((long) value); return true;
            case "converters": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setConverters((java.lang.String) value); return true;
            case "customMetricTags": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setCustomMetricTags((java.lang.String) value); return true;
            case "customSanitizePattern": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setCustomSanitizePattern((java.lang.String) value); return true;
            case "databaseHostname": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabaseHostname((java.lang.String) value); return true;
            case "databaseInstance": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabaseInstance((java.lang.String) value); return true;
            case "databaseNames": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabaseNames((java.lang.String) value); return true;
            case "databasePassword": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabasePassword((java.lang.String) value); return true;
            case "databasePort": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabasePort((int) value); return true;
            case "databaseQueryTimeoutMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabaseQueryTimeoutMs((int) value); return true;
            case "databaseUser": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabaseUser((java.lang.String) value); return true;
            case "dataQueryMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDataQueryMode((java.lang.String) value); return true;
            case "datatypePropagateSourceType": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatatypePropagateSourceType((java.lang.String) value); return true;
            case "decimalHandlingMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDecimalHandlingMode((java.lang.String) value); return true;
            case "errorsMaxRetries": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setErrorsMaxRetries((int) value); return true;
            case "eventProcessingFailureHandlingMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setEventProcessingFailureHandlingMode((java.lang.String) value); return true;
            case "executorShutdownTimeoutMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setExecutorShutdownTimeoutMs((long) value); return true;
            case "extendedHeadersEnabled": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setExtendedHeadersEnabled((boolean) value); return true;
            case "guardrailCollectionsLimitAction": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setGuardrailCollectionsLimitAction((java.lang.String) value); return true;
            case "guardrailCollectionsMax": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setGuardrailCollectionsMax((int) value); return true;
            case "heartbeatActionQuery": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setHeartbeatActionQuery((java.lang.String) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setHeartbeatIntervalMs((int) value); return true;
            case "heartbeatTopicsPrefix": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setHeartbeatTopicsPrefix((java.lang.String) value); return true;
            case "includeSchemaChanges": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setIncludeSchemaChanges((boolean) value); return true;
            case "includeSchemaComments": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setIncludeSchemaComments((boolean) value); return true;
            case "incrementalSnapshotAllowSchemaChanges": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setIncrementalSnapshotAllowSchemaChanges((boolean) value); return true;
            case "incrementalSnapshotChunkSize": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setIncrementalSnapshotChunkSize((int) value); return true;
            case "incrementalSnapshotOptionRecompile": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setIncrementalSnapshotOptionRecompile((boolean) value); return true;
            case "incrementalSnapshotWatermarkingStrategy": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setIncrementalSnapshotWatermarkingStrategy((java.lang.String) value); return true;
            case "maxBatchSize": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setMaxBatchSize((int) value); return true;
            case "maxIterationTransactions": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setMaxIterationTransactions((int) value); return true;
            case "maxQueueSize": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setMaxQueueSize((int) value); return true;
            case "maxQueueSizeInBytes": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setMaxQueueSizeInBytes((long) value); return true;
            case "messageKeyColumns": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setMessageKeyColumns((java.lang.String) value); return true;
            case "notificationEnabledChannels": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setNotificationEnabledChannels((java.lang.String) value); return true;
            case "notificationSinkTopicName": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setNotificationSinkTopicName((java.lang.String) value); return true;
            case "openlineageIntegrationConfigFilePath": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationConfigFilePath((java.lang.String) value); return true;
            case "openlineageIntegrationDatasetKafkaBootstrapServers": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationDatasetKafkaBootstrapServers((java.lang.String) value); return true;
            case "openlineageIntegrationEnabled": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationEnabled((boolean) value); return true;
            case "openlineageIntegrationJobDescription": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationJobDescription((java.lang.String) value); return true;
            case "openlineageIntegrationJobNamespace": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationJobNamespace((java.lang.String) value); return true;
            case "openlineageIntegrationJobOwners": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationJobOwners((java.lang.String) value); return true;
            case "openlineageIntegrationJobTags": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationJobTags((java.lang.String) value); return true;
            case "pollIntervalMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setPollIntervalMs((long) value); return true;
            case "postProcessors": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setPostProcessors((java.lang.String) value); return true;
            case "provideTransactionMetadata": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setProvideTransactionMetadata((boolean) value); return true;
            case "retriableRestartConnectorWaitMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setRetriableRestartConnectorWaitMs((long) value); return true;
            case "schemaHistoryInternal": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSchemaHistoryInternal((java.lang.String) value); return true;
            case "schemaHistoryInternalFileFilename": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSchemaHistoryInternalFileFilename((java.lang.String) value); return true;
            case "schemaHistoryInternalSkipUnparseableDdl": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSchemaHistoryInternalSkipUnparseableDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedDatabasesDdl": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSchemaHistoryInternalStoreOnlyCapturedDatabasesDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedTablesDdl": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSchemaHistoryInternalStoreOnlyCapturedTablesDdl((boolean) value); return true;
            case "schemaNameAdjustmentMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSchemaNameAdjustmentMode((java.lang.String) value); return true;
            case "signalDataCollection": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSignalDataCollection((java.lang.String) value); return true;
            case "signalEnabledChannels": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSignalEnabledChannels((java.lang.String) value); return true;
            case "signalPollIntervalMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSignalPollIntervalMs((long) value); return true;
            case "skippedOperations": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSkippedOperations((java.lang.String) value); return true;
            case "snapshotDelayMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotDelayMs((long) value); return true;
            case "snapshotFetchSize": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotFetchSize((int) value); return true;
            case "snapshotIncludeCollectionList": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotIncludeCollectionList((java.lang.String) value); return true;
            case "snapshotIsolationMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotIsolationMode((java.lang.String) value); return true;
            case "snapshotLockTimeoutMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotLockTimeoutMs((long) value); return true;
            case "snapshotMaxThreads": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotMaxThreads((int) value); return true;
            case "snapshotMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotMode((java.lang.String) value); return true;
            case "snapshotModeConfigurationBasedSnapshotData": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotModeConfigurationBasedSnapshotData((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnDataError": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotModeConfigurationBasedSnapshotOnDataError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnSchemaError": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotModeConfigurationBasedSnapshotOnSchemaError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotSchema": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotModeConfigurationBasedSnapshotSchema((boolean) value); return true;
            case "snapshotModeConfigurationBasedStartStream": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotModeConfigurationBasedStartStream((boolean) value); return true;
            case "snapshotModeCustomName": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotModeCustomName((java.lang.String) value); return true;
            case "snapshotSelectStatementOverrides": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotSelectStatementOverrides((java.lang.String) value); return true;
            case "snapshotTablesOrderByRowCount": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotTablesOrderByRowCount((java.lang.String) value); return true;
            case "sourceinfoStructMaker": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSourceinfoStructMaker((java.lang.String) value); return true;
            case "streamingDelayMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setStreamingDelayMs((long) value); return true;
            case "streamingFetchSize": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setStreamingFetchSize((int) value); return true;
            case "tableExcludeList": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTableExcludeList((java.lang.String) value); return true;
            case "tableIgnoreBuiltin": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTableIgnoreBuiltin((boolean) value); return true;
            case "tableIncludeList": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTableIncludeList((java.lang.String) value); return true;
            case "timePrecisionMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTimePrecisionMode((java.lang.String) value); return true;
            case "tombstonesOnDelete": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTombstonesOnDelete((boolean) value); return true;
            case "topicNamingStrategy": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTopicNamingStrategy((java.lang.String) value); return true;
            case "topicPrefix": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTopicPrefix((java.lang.String) value); return true;
            case "transactionMetadataFactory": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTransactionMetadataFactory((java.lang.String) value); return true;
            default: return false;
            }
        }

    public Object unmarshal(final Exchange exchange, final InputStream inputStream) throws Exception {
        InputStream compressedInput = null;

        OutputStreamBuilder osb = OutputStreamBuilder.withExchange(exchange);
        try {
            compressedInput = new LZFInputStream(inputStream);
            IOHelper.copy(compressedInput, osb);
            return osb.build();
        } finally {
             
            IOHelper.close(osb, compressedInput, inputStream);
        }
    }

    private static ValidatorReifier<? extends ValidatorDefinition> coreReifier(
            CamelContext camelContext, ValidatorDefinition definition) {
        if (definition instanceof CustomValidatorDefinition) {
            return new CustomValidatorReifier(camelContext, definition);
        } else if (definition instanceof EndpointValidatorDefinition) {
            return new EndpointValidatorReifier(camelContext, definition);
        } else if (definition instanceof PredicateValidatorDefinition) {
            return new PredicateValidatorReifier(camelContext, definition);
        }
        return null;
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();
        if (propertiesFunction != null) {
            root.put("masterUrl", propertiesFunction.getClient().getMasterUrl().toString());
            root.put("login", "OAuth Token");
        }
        KubernetesVaultConfiguration kubernetes = getCamelContext().getVaultConfiguration().getKubernetesVaultConfiguration();
        if (kubernetes != null) {
            root.put("refreshEnabled", kubernetes.isRefreshEnabled());
        }
        if (cmRefreshTask != null) {
            Instant start = cmRefreshTask.getStartingTime();
            if (start != null) {
                long timestamp = start.toEpochMilli();
                root.put("startCheckTimestamp", timestamp);
            }
        }
        JsonArray arr = new JsonArray();
        root.put("configmaps", arr);

        List<String> sorted = new ArrayList<>(List.of(kubernetes.getSecrets().split(",")));
        Collections.sort(sorted);

        for (String sec : sorted) {
            JsonObject jo = new JsonObject();
            jo.put("name", sec);
            arr.add(jo);
        }
        return root;
    }

    public Object getHeader(String name, Supplier<Object> defaultValueSupplier) {
        Object answer = null;

        if (headers == null) {
             
            headers = createHeaders();
        }

        if (!headers.isEmpty()) {
            answer = headers.get(name);
        }
        return answer != null ? answer : defaultValueSupplier.get();
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "bridgeErrorHandler": ((DebeziumSqlserverComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "configuration": ((DebeziumSqlserverComponent) component).setConfiguration((org.apache.camel.component.debezium.sqlserver.configuration.SqlServerConnectorEmbeddedDebeziumConfiguration) value); return true;
            case "internalKeyConverter": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setInternalKeyConverter((java.lang.String) value); return true;
            case "internalValueConverter": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setInternalValueConverter((java.lang.String) value); return true;
            case "offsetCommitPolicy": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetCommitPolicy((java.lang.String) value); return true;
            case "offsetCommitTimeoutMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetCommitTimeoutMs((long) value); return true;
            case "offsetFlushIntervalMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetFlushIntervalMs((long) value); return true;
            case "offsetStorage": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetStorage((java.lang.String) value); return true;
            case "offsetStorageFileName": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetStorageFileName((java.lang.String) value); return true;
            case "offsetStoragePartitions": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetStoragePartitions((int) value); return true;
            case "offsetStorageReplicationFactor": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetStorageReplicationFactor((int) value); return true;
            case "offsetStorageTopic": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOffsetStorageTopic((java.lang.String) value); return true;
            case "autowiredEnabled": ((DebeziumSqlserverComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "binaryHandlingMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setBinaryHandlingMode((java.lang.String) value); return true;
            case "columnExcludeList": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setColumnExcludeList((java.lang.String) value); return true;
            case "columnIncludeList": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setColumnIncludeList((java.lang.String) value); return true;
            case "columnPropagateSourceType": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setColumnPropagateSourceType((java.lang.String) value); return true;
            case "connectionValidationTimeoutMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setConnectionValidationTimeoutMs((long) value); return true;
            case "converters": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setConverters((java.lang.String) value); return true;
            case "customMetricTags": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setCustomMetricTags((java.lang.String) value); return true;
            case "customSanitizePattern": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setCustomSanitizePattern((java.lang.String) value); return true;
            case "databaseHostname": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabaseHostname((java.lang.String) value); return true;
            case "databaseInstance": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabaseInstance((java.lang.String) value); return true;
            case "databaseNames": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabaseNames((java.lang.String) value); return true;
            case "databasePassword": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabasePassword((java.lang.String) value); return true;
            case "databasePort": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabasePort((int) value); return true;
            case "databaseQueryTimeoutMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabaseQueryTimeoutMs((int) value); return true;
            case "databaseUser": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatabaseUser((java.lang.String) value); return true;
            case "dataQueryMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDataQueryMode((java.lang.String) value); return true;
            case "datatypePropagateSourceType": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDatatypePropagateSourceType((java.lang.String) value); return true;
            case "decimalHandlingMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setDecimalHandlingMode((java.lang.String) value); return true;
            case "errorsMaxRetries": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setErrorsMaxRetries((int) value); return true;
            case "eventProcessingFailureHandlingMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setEventProcessingFailureHandlingMode((java.lang.String) value); return true;
            case "executorShutdownTimeoutMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setExecutorShutdownTimeoutMs((long) value); return true;
            case "extendedHeadersEnabled": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setExtendedHeadersEnabled((boolean) value); return true;
            case "guardrailCollectionsLimitAction": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setGuardrailCollectionsLimitAction((java.lang.String) value); return true;
            case "guardrailCollectionsMax": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setGuardrailCollectionsMax((int) value); return true;
            case "heartbeatActionQuery": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setHeartbeatActionQuery((java.lang.String) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setHeartbeatIntervalMs((int) value); return true;
            case "heartbeatTopicsPrefix": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setHeartbeatTopicsPrefix((java.lang.String) value); return true;
            case "includeSchemaChanges": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setIncludeSchemaChanges((boolean) value); return true;
            case "includeSchemaComments": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setIncludeSchemaComments((boolean) value); return true;
            case "incrementalSnapshotAllowSchemaChanges": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setIncrementalSnapshotAllowSchemaChanges((boolean) value); return true;
            case "incrementalSnapshotChunkSize": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setIncrementalSnapshotChunkSize((int) value); return true;
            case "incrementalSnapshotOptionRecompile": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setIncrementalSnapshotOptionRecompile((boolean) value); return true;
            case "incrementalSnapshotWatermarkingStrategy": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setIncrementalSnapshotWatermarkingStrategy((java.lang.String) value); return true;
            case "maxBatchSize": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setMaxBatchSize((int) value); return true;
            case "maxIterationTransactions": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setMaxIterationTransactions((int) value); return true;
            case "maxQueueSize": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setMaxQueueSize((int) value); return true;
            case "maxQueueSizeInBytes": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setMaxQueueSizeInBytes((long) value); return true;
            case "messageKeyColumns": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setMessageKeyColumns((java.lang.String) value); return true;
            case "notificationEnabledChannels": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setNotificationEnabledChannels((java.lang.String) value); return true;
            case "notificationSinkTopicName": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setNotificationSinkTopicName((java.lang.String) value); return true;
            case "openlineageIntegrationConfigFilePath": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationConfigFilePath((java.lang.String) value); return true;
            case "openlineageIntegrationDatasetKafkaBootstrapServers": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationDatasetKafkaBootstrapServers((java.lang.String) value); return true;
            case "openlineageIntegrationEnabled": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationEnabled((boolean) value); return true;
            case "openlineageIntegrationJobDescription": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationJobDescription((java.lang.String) value); return true;
            case "openlineageIntegrationJobNamespace": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationJobNamespace((java.lang.String) value); return true;
            case "openlineageIntegrationJobOwners": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationJobOwners((java.lang.String) value); return true;
            case "openlineageIntegrationJobTags": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setOpenlineageIntegrationJobTags((java.lang.String) value); return true;
            case "pollIntervalMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setPollIntervalMs((long) value); return true;
            case "postProcessors": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setPostProcessors((java.lang.String) value); return true;
            case "provideTransactionMetadata": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setProvideTransactionMetadata((boolean) value); return true;
            case "retriableRestartConnectorWaitMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setRetriableRestartConnectorWaitMs((long) value); return true;
            case "schemaHistoryInternal": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSchemaHistoryInternal((java.lang.String) value); return true;
            case "schemaHistoryInternalFileFilename": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSchemaHistoryInternalFileFilename((java.lang.String) value); return true;
            case "schemaHistoryInternalSkipUnparseableDdl": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSchemaHistoryInternalSkipUnparseableDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedDatabasesDdl": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSchemaHistoryInternalStoreOnlyCapturedDatabasesDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedTablesDdl": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSchemaHistoryInternalStoreOnlyCapturedTablesDdl((boolean) value); return true;
            case "schemaNameAdjustmentMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSchemaNameAdjustmentMode((java.lang.String) value); return true;
            case "signalDataCollection": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSignalDataCollection((java.lang.String) value); return true;
            case "signalEnabledChannels": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSignalEnabledChannels((java.lang.String) value); return true;
            case "signalPollIntervalMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSignalPollIntervalMs((long) value); return true;
            case "skippedOperations": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSkippedOperations((java.lang.String) value); return true;
            case "snapshotDelayMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotDelayMs((long) value); return true;
            case "snapshotFetchSize": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotFetchSize((int) value); return true;
            case "snapshotIncludeCollectionList": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotIncludeCollectionList((java.lang.String) value); return true;
            case "snapshotIsolationMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotIsolationMode((java.lang.String) value); return true;
            case "snapshotLockTimeoutMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotLockTimeoutMs((long) value); return true;
            case "snapshotMaxThreads": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotMaxThreads((int) value); return true;
            case "snapshotMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotMode((java.lang.String) value); return true;
            case "snapshotModeConfigurationBasedSnapshotData": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotModeConfigurationBasedSnapshotData((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnDataError": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotModeConfigurationBasedSnapshotOnDataError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnSchemaError": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotModeConfigurationBasedSnapshotOnSchemaError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotSchema": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotModeConfigurationBasedSnapshotSchema((boolean) value); return true;
            case "snapshotModeConfigurationBasedStartStream": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotModeConfigurationBasedStartStream((boolean) value); return true;
            case "snapshotModeCustomName": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotModeCustomName((java.lang.String) value); return true;
            case "snapshotSelectStatementOverrides": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotSelectStatementOverrides((java.lang.String) value); return true;
            case "snapshotTablesOrderByRowCount": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSnapshotTablesOrderByRowCount((java.lang.String) value); return true;
            case "sourceinfoStructMaker": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setSourceinfoStructMaker((java.lang.String) value); return true;
            case "streamingDelayMs": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setStreamingDelayMs((long) value); return true;
            case "streamingFetchSize": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setStreamingFetchSize((int) value); return true;
            case "tableExcludeList": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTableExcludeList((java.lang.String) value); return true;
            case "tableIgnoreBuiltin": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTableIgnoreBuiltin((boolean) value); return true;
            case "tableIncludeList": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTableIncludeList((java.lang.String) value); return true;
            case "timePrecisionMode": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTimePrecisionMode((java.lang.String) value); return true;
            case "tombstonesOnDelete": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTombstonesOnDelete((boolean) value); return true;
            case "topicNamingStrategy": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTopicNamingStrategy((java.lang.String) value); return true;
            case "topicPrefix": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTopicPrefix((java.lang.String) value); return true;
            case "transactionMetadataFactory": getOrCreateConfiguration((DebeziumSqlserverComponent) component).setTransactionMetadataFactory((java.lang.String) value); return true;
            default: return false;
            }
        }

    private String calculateRouteCoverage(ManagedRouteGroupMBean mrg, boolean percent) {
        ManagedCamelContext mcc = getCamelContext().getCamelContextExtension().getContextPlugin(ManagedCamelContext.class);

        Collection<String> ids = new ArrayList<>();
        for (String id : mrg.getGroupIds()) {
            ManagedRouteMBean mrb = mcc.getManagedRoute(id);
            try {
                ids.addAll(mrb.processorIds());
            } catch (Exception e) {
                return null;
            }
        }

        int total = ids.size();
        int covered = 0;

        for (String id : ids) {
            ManagedProcessorMBean mp = mcc.getManagedProcessor(id);
            if (mp != null) {
                if (mp.getExchangesTotal() > 0) {
                    covered++;
                }
            }
        }

        if (percent) {
            double p;
            if (total > 0) {
                p = ((double) covered / total) * 100;
            } else {
                p = 0;
            }
            String f = String.format("%.0f", p);
            return covered + "/" + total + " (" + f + "%)";
        } else {
            return covered + "/" + total;
        }
    }

        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }
            if (obj == null) {
                return false;

            }
            if (getClass() != obj.getClass()) {
                return false;
            }
            ProcessorNameAndMessageId other = (ProcessorNameAndMessageId) obj;
            if (messageId == null) {
                if (other.messageId != null) {
                    return false;
                }
            } else if (!messageId.equals(other.messageId)) {
                return false;
            }
            if (processorName == null) {
                if (other.processorName != null) {
                    return false;
                }
            } else if (!processorName.equals(other.processorName)) {
                return false;
            }
            return true;
        }

    public String dumpStatisticsAsJson() {
        ObjectWriter writer = mapper.writer();
        if (isPrettyPrint()) {
            writer = writer.withDefaultPrettyPrinter();
        }
        try {
            return writer.writeValueAsString(getMetricsRegistry());
        } catch (JsonProcessingException e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    private String getAlgorithmName(String algorithm) {
        try {
            return PQCSignatureAlgorithms.valueOf(algorithm).getAlgorithm();
        } catch (IllegalArgumentException e1) {
            try {
                return PQCKeyEncapsulationAlgorithms.valueOf(algorithm).getAlgorithm();
            } catch (IllegalArgumentException e2) {
                return algorithm;
            }
        }
    }

    protected Configuration createConnectorConfiguration() {
        final Configuration.Builder configBuilder = Configuration.create();
        
        addPropertyIfNotNull(configBuilder, "transaction.metadata.factory", transactionMetadataFactory);
        addPropertyIfNotNull(configBuilder, "streaming.delay.ms", streamingDelayMs);
        addPropertyIfNotNull(configBuilder, "custom.metric.tags", customMetricTags);
        addPropertyIfNotNull(configBuilder, "mongodb.connection.string", mongodbConnectionString);
        addPropertyIfNotNull(configBuilder, "mongodb.password", mongodbPassword);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.namespace", openlineageIntegrationJobNamespace);
        addPropertyIfNotNull(configBuilder, "query.fetch.size", queryFetchSize);
        addPropertyIfNotNull(configBuilder, "signal.enabled.channels", signalEnabledChannels);
        addPropertyIfNotNull(configBuilder, "mongodb.ssl.enabled", mongodbSslEnabled);
        addPropertyIfNotNull(configBuilder, "cursor.max.await.time.ms", cursorMaxAwaitTimeMs);
        addPropertyIfNotNull(configBuilder, "field.renames", fieldRenames);
        addPropertyIfNotNull(configBuilder, "mongodb.server.selection.timeout.ms", mongodbServerSelectionTimeoutMs);
        addPropertyIfNotNull(configBuilder, "poll.interval.ms", pollIntervalMs);
        addPropertyIfNotNull(configBuilder, "guardrail.collections.max", guardrailCollectionsMax);
        addPropertyIfNotNull(configBuilder, "signal.data.collection", signalDataCollection);
        addPropertyIfNotNull(configBuilder, "converters", converters);
        addPropertyIfNotNull(configBuilder, "heartbeat.topics.prefix", heartbeatTopicsPrefix);
        addPropertyIfNotNull(configBuilder, "mongodb.connect.timeout.ms", mongodbConnectTimeoutMs);
        addPropertyIfNotNull(configBuilder, "snapshot.fetch.size", snapshotFetchSize);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.tags", openlineageIntegrationJobTags);
        addPropertyIfNotNull(configBuilder, "mongodb.poll.interval.ms", mongodbPollIntervalMs);
        addPropertyIfNotNull(configBuilder, "incremental.snapshot.watermarking.strategy", incrementalSnapshotWatermarkingStrategy);
        addPropertyIfNotNull(configBuilder, "mongodb.user", mongodbUser);
        addPropertyIfNotNull(configBuilder, "heartbeat.interval.ms", heartbeatIntervalMs);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.on.schema.error", snapshotModeConfigurationBasedSnapshotOnSchemaError);
        addPropertyIfNotNull(configBuilder, "snapshot.collection.filter.overrides", snapshotCollectionFilterOverrides);
        addPropertyIfNotNull(configBuilder, "field.exclude.list", fieldExcludeList);
        addPropertyIfNotNull(configBuilder, "errors.max.retries", errorsMaxRetries);
        addPropertyIfNotNull(configBuilder, "database.exclude.list", databaseExcludeList);
        addPropertyIfNotNull(configBuilder, "max.batch.size", maxBatchSize);
        addPropertyIfNotNull(configBuilder, "skipped.operations", skippedOperations);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.description", openlineageIntegrationJobDescription);
        addPropertyIfNotNull(configBuilder, "topic.naming.strategy", topicNamingStrategy);
        addPropertyIfNotNull(configBuilder, "snapshot.mode", snapshotMode);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.data", snapshotModeConfigurationBasedSnapshotData);
        addPropertyIfNotNull(configBuilder, "extended.headers.enabled", extendedHeadersEnabled);
        addPropertyIfNotNull(configBuilder, "max.queue.size", maxQueueSize);
        addPropertyIfNotNull(configBuilder, "guardrail.collections.limit.action", guardrailCollectionsLimitAction);
        addPropertyIfNotNull(configBuilder, "custom.sanitize.pattern", customSanitizePattern);
        addPropertyIfNotNull(configBuilder, "collection.include.list", collectionIncludeList);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.owners", openlineageIntegrationJobOwners);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.config.file.path", openlineageIntegrationConfigFilePath);
        addPropertyIfNotNull(configBuilder, "retriable.restart.connector.wait.ms", retriableRestartConnectorWaitMs);
        addPropertyIfNotNull(configBuilder, "capture.mode", captureMode);
        addPropertyIfNotNull(configBuilder, "snapshot.delay.ms", snapshotDelayMs);
        addPropertyIfNotNull(configBuilder, "executor.shutdown.timeout.ms", executorShutdownTimeoutMs);
        addPropertyIfNotNull(configBuilder, "provide.transaction.metadata", provideTransactionMetadata);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.on.data.error", snapshotModeConfigurationBasedSnapshotOnDataError);
        addPropertyIfNotNull(configBuilder, "schema.history.internal.file.filename", schemaHistoryInternalFileFilename);
        addPropertyIfNotNull(configBuilder, "tombstones.on.delete", tombstonesOnDelete);
        addPropertyIfNotNull(configBuilder, "topic.prefix", topicPrefix);
        addPropertyIfNotNull(configBuilder, "sourceinfo.struct.maker", sourceinfoStructMaker);
        addPropertyIfNotNull(configBuilder, "mongodb.authsource", mongodbAuthsource);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.dataset.kafka.bootstrap.servers", openlineageIntegrationDatasetKafkaBootstrapServers);
        addPropertyIfNotNull(configBuilder, "collection.exclude.list", collectionExcludeList);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.enabled", openlineageIntegrationEnabled);
        addPropertyIfNotNull(configBuilder, "snapshot.include.collection.list", snapshotIncludeCollectionList);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.start.stream", snapshotModeConfigurationBasedStartStream);
        addPropertyIfNotNull(configBuilder, "max.queue.size.in.bytes", maxQueueSizeInBytes);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.schema", snapshotModeConfigurationBasedSnapshotSchema);
        addPropertyIfNotNull(configBuilder, "signal.poll.interval.ms", signalPollIntervalMs);
        addPropertyIfNotNull(configBuilder, "post.processors", postProcessors);
        addPropertyIfNotNull(configBuilder, "notification.enabled.channels", notificationEnabledChannels);
        addPropertyIfNotNull(configBuilder, "mongodb.socket.timeout.ms", mongodbSocketTimeoutMs);
        addPropertyIfNotNull(configBuilder, "event.processing.failure.handling.mode", eventProcessingFailureHandlingMode);
        addPropertyIfNotNull(configBuilder, "snapshot.max.threads", snapshotMaxThreads);
        addPropertyIfNotNull(configBuilder, "notification.sink.topic.name", notificationSinkTopicName);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.custom.name", snapshotModeCustomName);
        addPropertyIfNotNull(configBuilder, "schema.name.adjustment.mode", schemaNameAdjustmentMode);
        addPropertyIfNotNull(configBuilder, "mongodb.ssl.invalid.hostname.allowed", mongodbSslInvalidHostnameAllowed);
        addPropertyIfNotNull(configBuilder, "mongodb.heartbeat.frequency.ms", mongodbHeartbeatFrequencyMs);
        addPropertyIfNotNull(configBuilder, "connection.validation.timeout.ms", connectionValidationTimeoutMs);
        addPropertyIfNotNull(configBuilder, "database.include.list", databaseIncludeList);
        
        return configBuilder.build();
    }

    public Short getShort(final int index) {
        Object returnable = this.get(index);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).shortValue();
    }

    private boolean updateOptionsIn(final File file, final String kind, final String changed) throws MojoExecutionException {
        if (!file.exists()) {
            return false;
        }

        final String updated = changed.trim();
        try {
            String text = PackageHelper.loadText(file);

            String existing = Strings.between(text, "// " + kind + " options: START", "// " + kind + " options: END");
            if (existing != null) {
                 
                existing = existing.trim();
                if (existing.equals(updated)) {
                    return false;
                }

                String before = Strings.before(text, "// " + kind + " options: START");
                String after = Strings.after(text, "// " + kind + " options: END");
                text = before + "// " + kind + " options: START\n" + updated + "\n// " + kind + " options: END" + after;
                PackageHelper.writeText(file, text);
                return true;
            }

            getLog().warn("Cannot find markers in file " + file);
            getLog().warn("Add the following markers");
            getLog().warn("\t// " + kind + " options: START");
            getLog().warn("\t// " + kind + " options: END");
            if (isFailFast()) {
                throw new MojoExecutionException("Failed build due failFast=true");
            }
            return false;
        } catch (IOException e) {
            throw new MojoExecutionException("Error reading file " + file + " Reason: " + e, e);
        }
    }

    public void onInvalidateAll(Message message) {
        Set<?> keys = message.getHeader(CaffeineConstants.KEYS, Set.class);
         
        if (keys == null) {
            cache.invalidateAll();
        } else {
            cache.invalidateAll(keys);
        }

        setResult(message, true, null, null);
    }

        public void parse(String systemId) throws IOException, SAXException {
            lock.lock();
            try {
                checkValid();
                try {
                    xmlReader.parse(systemId);
                } finally {
                    release();
                }
            } finally {
                lock.unlock();
            }
        }

    protected void doService(HttpServletRequest request, HttpServletResponse response) {
        log.trace("Service: {}", request);
        try {
            handleDoService(request, response);
        } catch (Exception e) {
             
            log.warn("Error handling request due to: {}", e.getMessage(), e);
            try {
                if (!response.isCommitted()) {
                    response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
                }
            } catch (Exception e1) {
                 
            }
        }
    }

    protected String getFrom(Row r) {
        String u = r.from;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    private void updateClientScope(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientScopeId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_SCOPE_ID, String.class);
        if (ObjectHelper.isEmpty(clientScopeId)) {
            throw new IllegalArgumentException("Client scope ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientScopeRepresentation) {
                keycloakClient.realm(realmName).clientScopes().get(clientScopeId).update((ClientScopeRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client scope updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client scope requires POJO request with ClientScopeRepresentation");
        }
    }

                public void onComplete(Exchange exchange) {
                     
                    Boolean close;
                    if (ExchangeHelper.isOutCapable(exchange)) {
                        close = exchange.getOut().getHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, Boolean.class);
                    } else {
                        close = exchange.getIn().getHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, Boolean.class);
                    }

                     
                    boolean disconnect = getConfiguration().isDisconnect();
                    if (close != null) {
                        disconnect = close;
                    }

                    if (disconnect) {
                        LOG.trace("Closing channel {} as routing the Exchange is done", channel);
                        NettyHelper.close(channel);
                    }

                    releaseChannel(channelFuture);
                }

    private RestartContainerCmd executeRestartContainerRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Restart Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);

        RestartContainerCmd restartContainerCmd = client.restartContainerCmd(containerId);

        Integer timeout = DockerHelper.getProperty(DockerConstants.DOCKER_TIMEOUT, configuration, message, Integer.class);

        if (timeout != null) {
            restartContainerCmd.withtTimeout(timeout);
        }

        return restartContainerCmd;

    }

    private Exchange createServiceBusExchange(final CloudEvent<byte[]> cloudEvent) {
        final Exchange exchange = createExchange(true);
        final Message message = exchange.getIn();

         
        message.setBody(cloudEvent.getData());

         
        message.setHeader(DaprConstants.PUBSUB_NAME, cloudEvent.getPubsubName());
        message.setHeader(DaprConstants.TOPIC, cloudEvent.getTopic());
        message.setHeader(DaprConstants.ID, cloudEvent.getId());
        message.setHeader(DaprConstants.SOURCE, cloudEvent.getSource());
        message.setHeader(DaprConstants.TYPE, cloudEvent.getType());
        message.setHeader(DaprConstants.SPECIFIC_VERSION, cloudEvent.getSpecversion());
        message.setHeader(DaprConstants.DATA_CONTENT_TYPE, cloudEvent.getDatacontenttype());
        message.setHeader(DaprConstants.BINARY_DATA, cloudEvent.getBinaryData());
        message.setHeader(DaprConstants.TIME, cloudEvent.getTime());
        message.setHeader(DaprConstants.TRACE_PARENT, cloudEvent.getTraceParent());
        message.setHeader(DaprConstants.TRACE_STATE, cloudEvent.getTraceState());

        return exchange;
    }

    public int processBatch(Queue<Object> exchanges) throws Exception {
        int total = exchanges.size();
        int answer = total;
        if (this.maxMessagesPerPoll > 0 && total > this.maxMessagesPerPoll) {
            LOG.debug("Limiting to maximum messages to poll {} as there were {} messages in this poll.",
                    this.maxMessagesPerPoll, total);
            total = this.maxMessagesPerPoll;
        }

        for (int index = 0; index < total && this.isBatchAllowed(); ++index) {
            Exchange exchange = (Exchange) exchanges.poll();
            exchange.setProperty(ExchangePropertyKey.BATCH_INDEX, index);
            exchange.setProperty(ExchangePropertyKey.BATCH_SIZE, total);
            exchange.setProperty(ExchangePropertyKey.BATCH_COMPLETE, index == total - 1);
            this.pendingExchanges = total - index - 1;
            getProcessor().process(exchange);
        }

        return answer;
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            applySecurityPolicy(exchange);
        } catch (Exception e) {
             
            exchange.setException(e);
            callback.done(true);
            return true;
        }

        return super.process(exchange, callback);
    }

    protected void doInit() throws Exception {
        super.doInit();
        if (meter == null) {
            this.meter = CamelContextHelper.findSingleByType(getCamelContext(), Meter.class);
        }
        if (meter == null) {
             
            this.meter = GlobalOpenTelemetry.get().getMeter("camel");
        }
        if (meter == null) {
            throw new RuntimeCamelException("Could not find any OpenTelemetry meter!");
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        getCurrentSagaCoordinator(exchange).whenComplete((coordinator, ex) -> ifNotException(ex, exchange, callback, () -> {
            if (coordinator == null) {
                exchange.setException(new CamelExchangeException("Exchange is not part of a saga", exchange));
                callback.done(false);
            } else {
                coordinator.beginStep(exchange, step)
                        .whenComplete((done, ex2) -> ifNotException(ex2, exchange, callback, () -> {
                            super.process(exchange, doneSync -> callback.done(false));
                        }));
            }
        }));
        return false;
    }

    public static EventProcessorClient createEventProcessorClient(
            final EventHubsConfiguration configuration, final Consumer<EventContext> processEvent,
            final Consumer<ErrorContext> processError) {
        EventProcessorClientBuilder eventProcessorClientBuilder = new EventProcessorClientBuilder()
                .initialPartitionEventPosition(configuration.getEventPosition())
                .checkpointStore(createCheckpointStore(configuration))
                .consumerGroup(configuration.getConsumerGroupName())
                .retryOptions(configuration.getAmqpRetryOptions())
                .transportType(configuration.getAmqpTransportType())
                .processError(processError)
                .processEvent(processEvent);

        CredentialType type = configuration.getCredentialType();
        if (type == null) {
            type = CredentialType.CONNECTION_STRING;
        }
        if (CredentialType.CONNECTION_STRING.equals(type)) {
            return eventProcessorClientBuilder
                    .connectionString(buildConnectionString(configuration))
                    .buildEventProcessorClient();
        } else if (CredentialType.TOKEN_CREDENTIAL.equals(type)) {

            checkTokenCredentialConfiguration(configuration);
            return eventProcessorClientBuilder
                    .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                    .eventHubName(configuration.getEventHubName())
                    .credential(configuration.getTokenCredential())
                    .buildEventProcessorClient();
        }
        return eventProcessorClientBuilder
                .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                .eventHubName(configuration.getEventHubName())
                .credential(new DefaultAzureCredentialBuilder().build())
                .buildEventProcessorClient();
    }

    public void process(Exchange exchange) throws Exception {
        Object payload = exchange.getMessage().getBody();
        if (payload == null) {
            return;
        }

        JsonNode answer = computeIfAbsent(exchange);

        if (answer != null) {
            exchange.setProperty(SchemaHelper.CONTENT_SCHEMA, answer);
            exchange.setProperty(SchemaHelper.CONTENT_SCHEMA_TYPE, SchemaType.JSON.type());
            exchange.setProperty(SchemaHelper.CONTENT_CLASS, SchemaHelper.resolveContentClass(exchange, this.contentClass));
        }
    }

    public Integer doCall() throws Exception {
        List<Long> pids = findPids(name);
        for (long pid : pids) {
            JsonObject root = new JsonObject();
            root.put("action", "reset-stats");
            Path f = getActionFile(Long.toString(pid));
            Files.writeString(f, root.toJson());
        }

        return 0;
    }

    private boolean existsRemote(ShareDirectoryClient dirClient) {
        try {
            return Boolean.TRUE.equals(
                    dirClient.existsWithResponse(endpoint.getMetadataTimeout(), Context.NONE).getValue());
        } catch (ShareStorageException ex) {
             
            if (ex.getStatusCode() == HTTP_NOT_FOUND) {
                return false;
            }
            throw ex;
        }
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        } else if (obj instanceof GenericArrayType) {
            return ((GenericArrayType) obj).getGenericComponentType().equals(componentType);
        } else {
            return false;
        }

    }

    public static Object[] toArray(Object object) {
        if (object instanceof Collection) {
            return ((Collection<?>) object).toArray();
        } else {
            Object[] answer;
            if (object == null) {
                answer = new Object[0];
            } else {
                answer = new Object[1];
                answer[0] = object;
            }
            return answer;
        }
    }

    protected void mapElement(ParserContext ctx, BeanDefinitionBuilder bean, Element el, String name) {
        if ("properties".equals(name) || "headers".equals(name)) {
            Map<?, ?> map = ctx.getDelegate().parseMapElement(el, bean.getBeanDefinition());
            bean.addPropertyValue(name, map);
        } else if ("binding".equals(name)) {
            setFirstChildAsProperty(el, ctx, bean, "bindingConfig");
        } else if ("inInterceptors".equals(name) || "inFaultInterceptors".equals(name)
                || "outInterceptors".equals(name) || "outFaultInterceptors".equals(name)) {
            List<?> list = ctx.getDelegate().parseListElement(el, bean.getBeanDefinition());
            bean.addPropertyValue(name, list);
        } else if ("features".equals(name) || "providers".equals(name)
                || "schemaLocations".equals(name) || "modelBeans".equals(name)) {
            List<?> list = ctx.getDelegate().parseListElement(el, bean.getBeanDefinition());
            bean.addPropertyValue(name, list);
        } else if ("model".equals(name)) {
            List<UserResource> resources = ResourceUtils.getResourcesFromElement(el);
            bean.addPropertyValue("modelBeans", resources);
        } else {
            setFirstChildAsProperty(el, ctx, bean, name);
        }
    }

    protected List<Configurer<SSLServerSocketFactory>> getSSLServerSocketFactoryConfigurers(SSLContext context) {

        final List<Configurer<SSLServerSocket>> sslServerSocketConfigurers
                = this.getSSLServerSocketFactorySSLServerSocketConfigurers(context);

        Configurer<SSLServerSocketFactory> sslServerSocketFactoryConfigurer = new Configurer<>() {

            @Override
            public SSLServerSocketFactory configure(SSLServerSocketFactory factory) {
                return new SSLServerSocketFactoryDecorator(
                        factory,
                        sslServerSocketConfigurers);
            }
        };

        List<Configurer<SSLServerSocketFactory>> sslServerSocketFactoryConfigurers = new LinkedList<>();
        sslServerSocketFactoryConfigurers.add(sslServerSocketFactoryConfigurer);

        return sslServerSocketFactoryConfigurers;
    }

    private static List<String> getDependencies(Object kamelet) throws Exception {
        List<String> answer = new ArrayList<>();
        Method m = kamelet.getClass().getMethod("getSpec");
        Object spec = ObjectHelper.invokeMethod(m, kamelet);
        m = spec.getClass().getMethod("getDependencies");
        @SuppressWarnings("unchecked")
        List<Object> list = (List<Object>) ObjectHelper.invokeMethod(m, spec);
        if (list != null && !list.isEmpty()) {
            for (var en : list) {
                String t = en.toString();
                t = StringHelper.removeLeadingAndEndingQuotes(t);
                answer.add(t);
            }
        }
        return answer.isEmpty() ? null : answer;
    }

    public static JsonObject asJsonObject(DevConsoleModel model) {
        JsonObject obj = new JsonObject();
        baseToJson(model, obj);
        artifactToJson(model, obj);
        obj.put("group", model.getGroup());
        obj.entrySet().removeIf(e -> e.getValue() == null);
        JsonObject wrapper = new JsonObject();
        wrapper.put("console", obj);
        return wrapper;
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        Message in = exchange.getIn();
        Message out = exchange.getOut();
        MessageHelper.copyHeaders(exchange.getIn(), out, true);

        switch (cacheOperationFor(exchange)) {

            case GET:
                doGet(in, out);
                break;

            case PUT:
                doPut(in, out);
                break;

            case QUERY:
                doQuery(in, out, exchange);
                break;

            case REMOVE:
                doRemove(in, out);
                break;

            case CLEAR:
                doClear(in, out);
                break;

            case SIZE:
                doSize(in, out);
                break;

            case REBALANCE:
                doRebalance(in, out);
                break;

            case REPLACE:
                doReplace(in, out);
                break;

            default:
                break;
        }

        callback.done(false);
        return false;
    }

        boolean executeFromQueue() {
            final Runnable polled = queue != null ? queue.pollFirst() : null;
            if (polled == null) {
                return false;
            }
            try {
                if (stats) {
                    executor.pendingTasks.decrement();
                }
                if (LOG.isTraceEnabled()) {
                    LOG.trace("Running: {}", polled);
                }
                polled.run();
            } catch (Exception e) {
                 
                LOG.warn("Error executing reactive work due to {}. This exception is ignored.", e.getMessage(), e);
            }
            return true;
        }

    private static Object asDefaultValue(String type, String defaultValue) {
        if (defaultValue != null) {
            if ("boolean".equals(type)) {
                return Boolean.parseBoolean(defaultValue);
            } else if ("integer".equals(type)) {
                return Integer.parseInt(defaultValue);
            }
        }
        if (defaultValue == null && "boolean".equals(type)) {
            return "false";
        }
        return defaultValue;
    }

    private static JsonObject getStatsObject(ManagedProcessorMBean mpb) {
        JsonObject stats = new JsonObject();
        stats.put("exchangesTotal", mpb.getExchangesTotal());
        stats.put("exchangesFailed", mpb.getExchangesFailed());
        stats.put("exchangesInflight", mpb.getExchangesInflight());
        stats.put("meanProcessingTime", mpb.getMeanProcessingTime());
        stats.put("maxProcessingTime", mpb.getMaxProcessingTime());
        stats.put("minProcessingTime", mpb.getMinProcessingTime());
        stats.put("lastProcessingTime", mpb.getLastProcessingTime());
        stats.put("deltaProcessingTime", mpb.getDeltaProcessingTime());
        stats.put("totalProcessingTime", mpb.getTotalProcessingTime());
        return stats;
    }

    public void uread(
            final Edm edm, final String resourcePath, final Map<String, String> queryParams,
            final Map<String, String> endpointHttpHeaders,
            final Olingo2ResponseHandler<InputStream> responseHandler) {

        final UriInfoWithType uriInfo = parseUri(edm, resourcePath, queryParams);

        execute(new HttpGet(createUri(resourcePath, encodeQueryParams(queryParams))), getResourceContentType(uriInfo),
                endpointHttpHeaders,
                new AbstractFutureCallback<InputStream>(responseHandler) {

                    @Override
                    public void onCompleted(HttpResponse result) throws IOException {
                        responseHandler.onResponse((result.getEntity() != null) ? result.getEntity().getContent() : null,
                                headersToMap(result.getAllHeaders()));
                    }

                });
    }

    private Iterable<?> filter(Iterable<?> iterable) {
        List<Object> filtered = new ArrayList<>();
        if (iterable == null) {
            return filtered;
        }

        for (Object o : iterable) {
            if (resultIndex.contains(o.hashCode())) {
                continue;
            }
            filtered.add(o);
        }

        return filtered;
    }

    public Short getShort(final String key) {
        Object returnable = this.get(key);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).shortValue();
    }

    protected void insert(
            final CamelContext camelContext, final String correlationId, final Exchange exchange, String repositoryName,
            final Long version, final boolean completed)
            throws Exception {
         
        int totalParameterIndex = 2;
        StringBuilder queryBuilder = new StringBuilder(256)
                .append("INSERT INTO ").append(repositoryName)
                .append('(')
                .append(EXCHANGE).append(", ")
                .append(ID);

        if (isStoreBodyAsText()) {
            queryBuilder.append(", ").append(BODY);
            totalParameterIndex++;
        }

        if (hasHeadersToStoreAsText()) {
            for (String headerName : getHeadersToStoreAsText()) {
                queryBuilder.append(", ").append(headerName);
                totalParameterIndex++;
            }
        }

        queryBuilder.append(") VALUES (");

        queryBuilder.append("?, ".repeat(Math.max(0, totalParameterIndex - 1)));
        queryBuilder.append("?)");

        queryBuilder.append(" ON CONFLICT DO NOTHING");

        String sql = queryBuilder.toString();

        int updateCount = insertHelper(camelContext, correlationId, exchange, sql, 1L, completed);
        if (updateCount == 0 && getRepositoryName().equals(repositoryName)) {
            throw new DataIntegrityViolationException("No row was inserted due to data violation");
        }
    }

    public ApplicationPkcs7MimeEnvelopedDataEntity(MimeEntity entity2Encrypt,
                                                   CMSEnvelopedDataGenerator dataGenerator,
                                                   OutputEncryptor encryptor,
                                                   String encryptedContentTransferEncoding,
                                                   boolean isMainBody)
                                                                       throws HttpException {
        super(ContentType.create("application/pkcs7-mime", new BasicNameValuePair("smime-type", "enveloped-data"),
                new BasicNameValuePair("name", "smime.p7m")),
              encryptedContentTransferEncoding);
        addHeader(AS2Header.CONTENT_DISPOSITION, CONTENT_DISPOSITION);
        setMainBody(isMainBody);
        try {
            this.encryptedData = createEncryptedData(entity2Encrypt, dataGenerator, encryptor);
        } catch (Exception e) {
            throw new HttpException("Failed to create encrypted data");
        }
    }

    private LogFactory inferLogFactory(SessionSettings settings) throws ConfigError {
        Set<LogFactory> impliedLogFactories = new HashSet<>();
        isFileLog(settings, impliedLogFactories);
        isScreenLog(settings, impliedLogFactories);
        isSL4JLog(settings, impliedLogFactories);
        isJdbcLog(settings, impliedLogFactories);
        if (impliedLogFactories.size() > 1) {
            throw new ConfigError("Ambiguous log factory implied in configuration");
        }
        LogFactory sessionLogFactory;
        if (impliedLogFactories.size() == 1) {
            sessionLogFactory = impliedLogFactories.iterator().next();
        } else {
             
            sessionLogFactory = new ScreenLogFactory(settings);
        }
        LOG.info("Inferring log factory: {}", sessionLogFactory.getClass().getName());
        return sessionLogFactory;
    }

    public static Predicate isGreaterThanOrEqualTo(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue == null && rightValue == null) {
                     
                    return true;
                } else if (leftValue == null || rightValue == null) {
                     
                    return false;
                }

                return ObjectHelper.typeCoerceCompare(exchange.getContext().getTypeConverter(), leftValue, rightValue) >= 0;
            }

            protected String getOperationText() {
                return ">=";
            }
        };
    }

    private String getAlgorithmName(String algorithm) {
        try {
            return PQCSignatureAlgorithms.valueOf(algorithm).getAlgorithm();
        } catch (IllegalArgumentException e1) {
            try {
                return PQCKeyEncapsulationAlgorithms.valueOf(algorithm).getAlgorithm();
            } catch (IllegalArgumentException e2) {
                return algorithm;
            }
        }
    }

    public static QueryBuilder query(final String query) {
        return new QueryBuilder() {
            protected Query makeQueryObject(EntityManager entityManager) {
                return entityManager.createQuery(query);
            }

            @Override
            public String toString() {
                return "Query: " + query + getParameterDescription();
            }
        };
    }

    public String getComponentJSonSchema(String name) {
        final String file = camelCatalog.getRuntimeProvider().getComponentJSonSchemaDirectory() + "/" + name + EXTENSION;

        final String fromVersionManager = loadResourceFromVersionManager(file);
        if (fromVersionManager != null) {
            return fromVersionManager;
        }

         
        final String answer = extraComponentsJSonSchema.get(name);
        if (answer != null) {
            return answer;
        }

         
        final String className = extraComponents.get(name);
        return loadFromClasspath(className, name);
    }

    private long determineDelay(final Exchange exchange, Athena2Configuration configuration) {
        Long delay = exchange.getIn().getHeader(Athena2Constants.DELAY, Long.class);

        if (ObjectHelper.isEmpty(delay)) {
            delay = configuration.getDelay();
            LOG.trace("AWS Athena delay is missing, using default one [{}]", delay);
        }

        if (ObjectHelper.isEmpty(delay)) {
            throw new IllegalArgumentException("AWS Athena delay is required.");
        }

        if (delay < 0) {
            throw new IllegalArgumentException("AWS Athena delay must be >= 0");
        }

        return delay;
    }

    public BraintreeConfiguration getEndpointConfiguration(BraintreeApiName apiName) {
        BraintreeConfiguration result = null;
        switch (apiName) {
            case ADD_ON:
                result = new AddOnGatewayEndpointConfiguration();
                break;
            case ADDRESS:
                result = new AddressGatewayEndpointConfiguration();
                break;
            case CLIENT_TOKEN:
                result = new ClientTokenGatewayEndpointConfiguration();
                break;
            case CREDIT_CARD_VERIFICATION:
                result = new CreditCardVerificationGatewayEndpointConfiguration();
                break;
            case CUSTOMER:
                result = new CustomerGatewayEndpointConfiguration();
                break;
            case DISCOUNT:
                result = new DiscountGatewayEndpointConfiguration();
                break;
            case DISPUTE:
                result = new DisputeGatewayEndpointConfiguration();
                break;
            case DOCUMENT_UPLOAD:
                result = new DocumentUploadGatewayEndpointConfiguration();
                break;
            case MERCHANT_ACCOUNT:
                result = new MerchantAccountGatewayEndpointConfiguration();
                break;
            case PAYMENT_METHOD:
                result = new PaymentMethodGatewayEndpointConfiguration();
                break;
            case PAYMENT_METHOD_NONCE:
                result = new PaymentMethodNonceGatewayEndpointConfiguration();
                break;
            case OAUTH:
                result = new OAuthGatewayEndpointConfiguration();
                break;
            case PLAN:
                result = new PlanGatewayEndpointConfiguration();
                break;
            case REPORT:
                result = new ReportGatewayEndpointConfiguration();
                break;
            case SETTLEMENT_BATCH_SUMMARY:
                result = new SettlementBatchSummaryGatewayEndpointConfiguration();
                break;
            case SUBSCRIPTION:
                result = new SubscriptionGatewayEndpointConfiguration();
                break;
            case TRANSACTION:
                result = new TransactionGatewayEndpointConfiguration();
                break;
            case US_BANK_ACCOUNT:
                result = new UsBankAccountGatewayEndpointConfiguration();
                break;
            case WEBHOOK_NOTIFICATION:
                result = new WebhookNotificationGatewayEndpointConfiguration();
                break;
        }
        return result;
    }

    public boolean hasNext() {
        try {
            if (asn1InputStream == null) {
                return false;
            }
            boolean availableDataInCurrentEntry = asn1InputStream.available() > 0;
            if (!availableDataInCurrentEntry) {
                 
                parent = getNextElement();
                if (parent == null) {
                    asn1InputStream.close();
                    availableDataInCurrentEntry = false;
                } else {
                    availableDataInCurrentEntry = true;
                }
            }
            return availableDataInCurrentEntry;
        } catch (IOException exception) {
            throw new RuntimeCamelException(exception);
        }
    }

        public XmlSignatureProperties.Input build() {
            return new XmlSignatureProperties.Input() {

                @Override
                public XMLSignatureFactory getSignatureFactory() {
                    return signatureFactory;
                }

                @Override
                public String getSignatureAlgorithm() {
                    return signatureAlgorithm;
                }

                @Override
                public Node getParent() {
                    return parent;
                }

                @Override
                public Node getMessageBodyNode() {
                    return messageBodyNode;
                }

                @Override
                public Message getMessage() {
                    return message;
                }

                @Override
                public KeyInfo getKeyInfo() {
                    return keyInfo;
                }

                @Override
                public String getContentDigestAlgorithm() {
                    return contentDigestAlgorithm;
                }

                @Override
                public String getSignatureId() {
                    return signatureId;
                }

                @Override
                public String getContentReferenceUri() {
                    return contentReferenceUri;
                }

                @Override
                public SignatureType getSignatureType() {
                    return signatureType;
                }

                @Override
                public String getPrefixForXmlSignatureNamespace() {
                    return prefixForXmlSignatureNamespace;
                }

            };
        }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {

        final CosmosDbConfiguration configuration
                = this.configuration != null ? this.configuration.copy() : new CosmosDbConfiguration();

        if (ObjectHelper.isNotEmpty(remaining) && !remaining.isBlank()) {
            final String[] parts = remaining.split("/");

             
            configuration.setDatabaseName(parts[0]);

             
            if (parts.length > 1) {
                configuration.setContainerName(parts[1]);
            }
        }

        final CosmosDbEndpoint endpoint = new CosmosDbEndpoint(uri, this, configuration);
        setProperties(endpoint, parameters);
        validateConfigurations(configuration);

        return endpoint;
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, byte[].class, ca.uhn.hl7v2.model.Message.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toByteArray((ca.uhn.hl7v2.model.Message) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, ca.uhn.hl7v2.model.Message.class, byte[].class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toMessage((byte[]) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, ca.uhn.hl7v2.model.Message.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toMessage((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, ca.uhn.hl7v2.model.Message.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toString((ca.uhn.hl7v2.model.Message) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void updateResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String resourceId = exchange.getIn().getHeader(KeycloakConstants.RESOURCE_ID, String.class);
        if (ObjectHelper.isEmpty(resourceId)) {
            throw new IllegalArgumentException("Resource ID must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources().resource(resourceId)
                        .update((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Resource updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update resource requires POJO request with ResourceRepresentation");
        }
    }

    public TabularData extendedInformation() {
        try {
            TabularData answer = new TabularDataSupport(CamelOpenMBeanTypes.endpointsUtilizationTabularType());

             
            CompositeType ct = CamelOpenMBeanTypes.endpointsUtilizationCompositeType();
            String url = getDestination();
            long hits = getProcessor().getCounter();

            CompositeData data = new CompositeDataSupport(ct, new String[] { "url", "hits" }, new Object[] { url, hits });
            answer.put(data);
            return answer;
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    protected void doStop() throws Exception {
        if (contextServicePlugins != null) {
            for (ContextServicePlugin plugin : contextServicePlugins) {
                try {
                    plugin.unload(camelContext);
                } catch (Exception e) {
                    LOG.warn(
                            "Unloading of plugin {} failed, however the exception will be ignored so shutdown can continue. Reason: {}",
                            plugin.getClass().getName(), e.getMessage(), e);
                }
            }
        }
    }

    public DmsClient initClient() {
        if (dmsClient != null) {
            return dmsClient;
        }

         
        if (ObjectHelper.isEmpty(getServiceKeys()) && ObjectHelper.isEmpty(getAccessKey())) {
            throw new IllegalArgumentException("Authentication parameter 'access key (AK)' not found");
        }
        if (ObjectHelper.isEmpty(getServiceKeys()) && ObjectHelper.isEmpty(getSecretKey())) {
            throw new IllegalArgumentException("Authentication parameter 'secret key (SK)' not found");
        }

         
        BasicCredentials auth = new BasicCredentials()
                .withAk(getServiceKeys() != null
                        ? getServiceKeys().getAccessKey()
                        : getAccessKey())
                .withSk(getServiceKeys() != null
                        ? getServiceKeys().getSecretKey()
                        : getSecretKey())
                .withProjectId(getProjectId());

         
        HttpConfig httpConfig = HttpConfig.getDefaultHttpConfig();
        httpConfig.withIgnoreSSLVerification(isIgnoreSslVerification());
        if (ObjectHelper.isNotEmpty(getProxyHost())
                && ObjectHelper.isNotEmpty(getProxyPort())) {
            httpConfig.withProxyHost(getProxyHost())
                    .withProxyPort(getProxyPort());

            if (ObjectHelper.isNotEmpty(getProxyUser())) {
                httpConfig.withProxyUsername(getProxyUser());
                if (ObjectHelper.isNotEmpty(getProxyPassword())) {
                    httpConfig.withProxyPassword(getProxyPassword());
                }
            }
        }

         
        if (ObjectHelper.isNotEmpty(getEndpoint())) {
            return DmsClient.newBuilder()
                    .withCredential(auth)
                    .withHttpConfig(httpConfig)
                    .withEndpoint(getEndpoint())
                    .build();
        } else {
            return DmsClient.newBuilder()
                    .withCredential(auth)
                    .withHttpConfig(httpConfig)
                    .withRegion(DmsRegion.valueOf(getRegion()))
                    .build();
        }
    }

    public TabularData browse() {
        try {
            TabularData answer = new TabularDataSupport(CamelOpenMBeanTypes.listAwaitThreadsTabularType());
            Collection<AsyncProcessorAwaitManager.AwaitThread> threads = manager.browse();
            for (AsyncProcessorAwaitManager.AwaitThread entry : threads) {
                CompositeType ct = CamelOpenMBeanTypes.listAwaitThreadsCompositeType();
                final CompositeData data = toCompositeData(entry, ct);
                answer.put(data);
            }
            return answer;
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    protected void loadResource(String resourceUri, XsltBuilder xslt) throws TransformerException, IOException {
        LOG.trace("{} loading schema resource: {}", this, resourceUri);
        Source source = xslt.getUriResolver().resolve(resourceUri, null);
        if (source == null) {
            throw new IOException("Cannot load schema resource " + resourceUri);
        } else {
            xslt.setTransformerSource(source);
        }
         
        cacheCleared = false;
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    protected boolean isMatched(
            Supplier<GenericFile<FileIdBothDirectoryInformation>> file, String doneFileName,
            FileIdBothDirectoryInformation[] files) {

        String onlyName = FileUtil.stripPath(doneFileName);
        for (FileIdBothDirectoryInformation f : files) {
            if (f.getFileName().equals(onlyName)) {
                return true;
            }
        }
        LOG.trace("Done file: {} does not exist", doneFileName);
        return false;
    }

    private void setupEndpointStrategies() {
        Map<String, EndpointStrategy> endpointStrategies
                = getContext().getRegistry().findByTypeWithName(EndpointStrategy.class);
        if (endpointStrategies != null && !endpointStrategies.isEmpty()) {
            for (Entry<String, EndpointStrategy> entry : endpointStrategies.entrySet()) {
                EndpointStrategy strategy = entry.getValue();
                LOG.info("Using custom EndpointStrategy with id: {} and implementation: {}", entry.getKey(), strategy);
                getContext().getCamelContextExtension().registerEndpointCallback(strategy);
            }
        }
    }

    private boolean sendAsyncEvents(
            final Iterable<EventData> eventData, final SendOptions sendOptions, final Exchange exchange,
            final AsyncCallback asyncCallback) {
        sendAsyncEventsWithSuitableMethod(eventData, sendOptions)
                .subscribe(unused -> LOG.debug("Processed one event..."), error -> {
                     
                    LOG.debug("Error processing async exchange with error: {}", error.getMessage());
                    exchange.setException(error);
                    asyncCallback.done(false);
                }, () -> {
                     
                    LOG.debug("All events with exchange have been sent successfully.");
                    asyncCallback.done(false);
                });

        return false;
    }

    private void updateUser(Exchange exchange, ClientConfigurations clientConfigurations) {
         
        Object body = exchange.getMessage().getBody();
        UpdateUserOption userOption;
        if (body instanceof UpdateUserOption) {
            userOption = (UpdateUserOption) body;
        } else if (body instanceof String) {
            String strBody = (String) body;
            try {
                userOption = new ObjectMapper().readValue(strBody, UpdateUserOption.class);
            } catch (JsonProcessingException e) {
                throw new IllegalArgumentException("String request body must be a valid JSON");
            }
        } else {
            throw new IllegalArgumentException(
                    "Exchange body is mandatory and should be a valid JSON string or UpdateUserOption object");
        }

         
        if (ObjectHelper.isEmpty(clientConfigurations.getUserId())) {
            if (LOG.isErrorEnabled()) {
                LOG.error("No user id given");
            }
            throw new IllegalArgumentException("User id is mandatory to update user");
        }

         
        UpdateUserRequestBody requestBody = new UpdateUserRequestBody()
                .withUser(userOption);
        UpdateUserRequest request = new UpdateUserRequest()
                .withBody(requestBody)
                .withUserId(clientConfigurations.getUserId());
        UpdateUserResponse response = iamClient.updateUser(request);
        exchange.getMessage().setBody(gson.toJson(response.getUser()));
    }

    public GenericFileProcessStrategy<SftpRemoteFile> createGenericFileProcessStrategy(
            CamelContext context, Map<String, Object> params) {

         
         
        Expression moveExpression = (Expression) params.get("move");
        Expression moveFailedExpression = (Expression) params.get("moveFailed");
        Expression preMoveExpression = (Expression) params.get("preMove");
        boolean isNoop = params.get("noop") != null;
        boolean isDelete = params.get("delete") != null;
        boolean isMove = moveExpression != null || preMoveExpression != null || moveFailedExpression != null;

        if (isDelete) {
            GenericFileDeleteProcessStrategy<SftpRemoteFile> strategy = new GenericFileDeleteProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<SftpRemoteFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<SftpRemoteFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
            return strategy;
        } else if (isMove || isNoop) {
            GenericFileRenameProcessStrategy<SftpRemoteFile> strategy = new GenericFileRenameProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (!isNoop && moveExpression != null) {
                 
                GenericFileExpressionRenamer<SftpRemoteFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveExpression);
                strategy.setCommitRenamer(renamer);
            }
             
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<SftpRemoteFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
             
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<SftpRemoteFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            return strategy;
        } else {
             
            GenericFileNoOpProcessStrategy<SftpRemoteFile> strategy = new GenericFileNoOpProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            return strategy;
        }
    }

    private static boolean isBulkOperation(OperationName operationName) {
        switch (operationName) {
            case CREATE_JOB:
            case GET_JOB:
            case CLOSE_JOB:
            case ABORT_JOB:
            case CREATE_BATCH:
            case GET_BATCH:
            case GET_ALL_BATCHES:
            case GET_REQUEST:
            case GET_RESULTS:
            case CREATE_BATCH_QUERY:
            case GET_QUERY_RESULT_IDS:
            case GET_QUERY_RESULT:
                return true;
            default:
                return false;
        }
    }

    public OrientationRequested assignOrientation(final String orientation) {
        OrientationRequested answer;

        if (orientation == null) {
             
            answer = OrientationRequested.PORTRAIT;
        } else if (orientation.equalsIgnoreCase("portrait")) {
            answer = OrientationRequested.PORTRAIT;
        } else if (orientation.equalsIgnoreCase("landscape")) {
            answer = OrientationRequested.LANDSCAPE;
        } else if (orientation.equalsIgnoreCase("reverse-portrait")) {
            answer = OrientationRequested.REVERSE_PORTRAIT;
        } else if (orientation.equalsIgnoreCase("reverse-landscape")) {
            answer = OrientationRequested.REVERSE_LANDSCAPE;
        } else {
            answer = OrientationRequested.PORTRAIT;
        }

        return answer;
    }

    protected boolean isMatched(
            Supplier<GenericFile<FileIdBothDirectoryInformation>> file, String doneFileName,
            FileIdBothDirectoryInformation[] files) {

        String onlyName = FileUtil.stripPath(doneFileName);
        for (FileIdBothDirectoryInformation f : files) {
            if (f.getFileName().equals(onlyName)) {
                return true;
            }
        }
        LOG.trace("Done file: {} does not exist", doneFileName);
        return false;
    }

    protected void autoConfigure(String artifactId) {
         
        InputStream is = getClass().getResourceAsStream("/auto-configure/" + artifactId + ".java");
        if (is != null) {
            try {
                 
                DependencyDownloader downloader = getCamelContext().hasService(DependencyDownloader.class);
                 
                downloader.downloadHiddenDependency("org.apache.camel", "camel-joor", camelContext.getVersion());
                 
                String script = IOHelper.loadText(is);
                Language lan = camelContext.resolveLanguage("java");
                Expression exp = lan.createExpression(script);
                Object out = exp.evaluate(new DefaultExchange(camelContext), Object.class);
                if (ObjectHelper.isNotEmpty(out)) {
                    LOG.info("{}", out);
                }
            } catch (Exception e) {
                throw RuntimeCamelException.wrapRuntimeException(e);
            } finally {
                IOHelper.close(is);
            }
        }
    }

    public ClosePullRequestProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_PULL_REQUEST_SERVICE);
        if (service != null) {
            pullRequestService = (PullRequestService) service;
        } else {
            pullRequestService = new PullRequestService();
        }
        initService(pullRequestService);
    }

    private void refreshStatusLosingLeadership() {
         
        long delay = this.lockConfiguration.getLeaseDurationMillis();
        LOG.info("{} Current pod owns the leadership, but it will be lost in {} seconds...", logPrefix,
                new BigDecimal(delay).divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_UP));

        try {
            Thread.sleep(delay);
        } catch (InterruptedException e) {
            LOG.warn("Thread interrupted", e);
            Thread.currentThread().interrupt();
        }

        LOG.info("{} Current pod is losing leadership now...", logPrefix);
        this.currentState = State.LEADERSHIP_LOST;
        this.serializedExecutor.execute(this::refreshStatus);
    }

    public static String extractSourceName(String loc) {
        loc = stripSourceLocationLineNumber(loc);
        if (loc != null) {
            if (loc.contains(":")) {
                 
                loc = loc.substring(loc.indexOf(':') + 1);
                 
                loc = FileUtil.stripPath(loc);
            }
        }
        return loc;
    }

    public boolean process(final Exchange exchange, final AsyncCallback callback) {
         
        final Map<String, Object> properties = new HashMap<>(endpoint.getEndpointProperties());
        propertiesHelper.getExchangeProperties(exchange, properties);

         
        endpoint.interceptProperties(properties);
        interceptProperties(properties);

         
        properties.put(Olingo2Endpoint.RESPONSE_HANDLER_PROPERTY, new Olingo2ResponseHandler<Object>() {
            @Override
            public void onResponse(Object response, Map<String, String> responseHeaders) {
                if (resultIndex != null) {
                    response = resultIndex.filterResponse(response);
                }

                 
                 
                exchange.getOut().setBody(response);
                 
                exchange.getOut().setHeaders(exchange.getIn().getHeaders());

                 
                exchange.getOut().setHeader(Olingo2Constants.RESPONSE_HTTP_HEADERS, responseHeaders);

                interceptResult(response, exchange);

                callback.done(false);
            }

            @Override
            public void onException(Exception ex) {
                exchange.setException(ex);
                callback.done(false);
            }

            @Override
            public void onCanceled() {
                exchange.setException(new RuntimeCamelException("OData HTTP Request cancelled!"));
                callback.done(false);
            }
        });

         
        final ApiMethod method = findMethod(exchange, properties);
        if (method == null) {
             
            callback.done(true);
            return true;
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Invoking operation {} with {}", method.getName(), properties.keySet());
        }

        try {
            doInvokeMethod(method, properties);
        } catch (Exception e) {
            exchange.setException(RuntimeCamelException.wrapRuntimeCamelException(e));
            callback.done(true);
            return true;
        }

        return false;
    }

    public Short getShort(final String key) {
        Object returnable = this.get(key);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).shortValue();
    }

    private static void toResult(Source source, Result result) throws TransformerException {
        if (source != null) {
            XMLConverterHelper xml = new XMLConverterHelper();
            TransformerFactory factory = xml.getTransformerFactory();
            Transformer transformer = factory.newTransformer();
            if (transformer == null) {
                throw new TransformerException("Could not create a transformer - JAXP is misconfigured!");
            } else {
                Properties outputProperties = new Properties();
                outputProperties.put("encoding", DEFAULT_CHARSET);
                outputProperties.put("omit-xml-declaration", "yes");

                transformer.setOutputProperties(outputProperties);
                transformer.transform(source, result);
            }
        }
    }

    private PropertiesFunction resolve(CamelContext context, String name) {
         
        Class<?> type = null;
        try {
            type = findFactory(name, context);
        } catch (Exception e) {
             
        }

        if (type != null) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Found PropertiesFunction: {} via: {}{}", type.getName(), factoryFinder.getResourcePath(), name);
            }
            if (PropertiesFunction.class.isAssignableFrom(type)) {
                PropertiesFunction answer = (PropertiesFunction) context.getInjector().newInstance(type, false);
                CamelContextAware.trySetCamelContext(answer, camelContext);
                ServiceHelper.startService(answer);
                return answer;
            } else {
                throw new IllegalArgumentException("Type is not a PropertiesFunction implementation. Found: " + type.getName());
            }
        }

        return null;
    }

    public int forceCompletionOfAllGroups() {

         
        boolean allow = camelContext.getStatus().isStarted() || camelContext.getStatus().isStopping();
        if (!allow) {
            LOG.warn("Cannot start force completion of all groups because CamelContext({}) has not been started",
                    camelContext.getName());
            return 0;
        }

        LOG.trace("Starting force completion of all groups task");

         
        Set<String> keys = aggregationRepository.getKeys();

        int total = 0;
        if (keys != null && !keys.isEmpty()) {
             
            lock.lock();
            total = keys.size();
            try {
                for (String key : keys) {
                    Exchange exchange = aggregationRepository.get(camelContext, key);
                    if (exchange != null) {
                        LOG.trace("Force completion triggered for correlation key: {}", key);
                         
                        exchange.setProperty(ExchangePropertyKey.AGGREGATED_COMPLETED_BY, COMPLETED_BY_FORCE);
                        Exchange answer = onCompletion(key, exchange, exchange, false, false);
                        if (answer != null) {
                            onSubmitCompletion(key, answer);
                        }
                    }
                }
            } finally {
                lock.unlock();
            }
        }
        LOG.trace("Completed force completion of all groups task");

        if (total > 0) {
            LOG.debug("Forcing completion of all groups with {} exchanges", total);
        }
        return total;
    }

    private void copyAgentLibDependencies(MavenGav gav) {
        try {
            List<MavenArtifact> artifacts = getDownloader().resolveArtifacts(
                    List.of(gav.toString()), Set.of(), true, gav.getVersion().contains("SNAPSHOT"));
            for (MavenArtifact artifact : artifacts) {
                Path target = Paths.get(BUILD_DIR, "agent", artifact.getFile().getName());
                if (Files.exists(target) || EXCLUDED_GROUP_IDS.contains(artifact.getGav().getGroupId())) {
                    continue;
                }
                Files.copy(artifact.getFile().toPath(), target);
            }
        } catch (MavenResolutionException e) {
            printer().printErr("Error resolving the artifact: " + gav + " due to: " + e.getMessage());
        } catch (IOException e) {
            printer().printErr("Error copying the artifact: " + gav + " due to: " + e.getMessage());
        }
    }

    public void setException(Throwable exception) {
        Objects.requireNonNull(exception, "exception must be not null");
        if (this.data != null) {
            throw new IllegalStateException("data has already been set");
        } else if (this.exception != null) {
            throw new IllegalStateException("an exception has already been set");
        }

        this.exception = exception;
        flushCycle();
    }

    private int downloadFromGithub() throws Exception {
        StringJoiner all = new StringJoiner(",");

        String ext = FileUtil.onlyExt(file);
        boolean wildcard = FileUtil.onlyName(file, false).contains("*");
        if (ext != null && !wildcard) {
             
            String url = asGithubSingleUrl(file);
            all.add(url);
        } else {
            fetchGithubUrls(file, all);
        }

        if (all.length() > 0) {
             
            if (!directory.equals(".")) {
                Path dirPath = Paths.get(directory);
                if (cleanDirectory) {
                     
                    CommandHelper.cleanExportDir(directory);
                }
                Files.createDirectories(dirPath);
            }

            CamelContext tiny = new DefaultCamelContext();
            try (GitHubResourceResolver resolver = new GitHubResourceResolver()) {
                resolver.setCamelContext(tiny);
                for (String u : all.toString().split(",")) {
                    Resource resource = resolver.resolve(u);
                    if (!resource.exists()) {
                        throw new ResourceDoesNotExist(resource);
                    }
                    String loc = resource.getLocation();
                    String name = FileUtil.stripPath(loc);
                    Path targetPath = Paths.get(directory, name);
                    try (OutputStream os = Files.newOutputStream(targetPath)) {
                        IOUtils.copy(resource.getInputStream(), os);
                    }
                }
            }
        }

        return 0;
    }

    public void releaseExclusiveReadLockOnCommit(
            GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
            throws Exception {
        String key = asKey(exchange, file);
        Runnable r = () -> {
            if (removeOnCommit) {
                idempotentRepository.remove(exchange, key);
            } else {
                 
                idempotentRepository.confirm(exchange, key);
            }
        };

        delayOrScheduleLockRelease(r);
    }

    protected void afterConfigureProperties() {
        switch (apiName) {
            case LIST:
                apiProxy = getClient().calendarList();
                break;
            case ACL:
                apiProxy = getClient().acl();
                break;
            case CALENDARS:
                apiProxy = getClient().calendars();
                break;
            case CHANNELS:
                apiProxy = getClient().channels();
                break;
            case COLORS:
                apiProxy = getClient().colors();
                break;
            case EVENTS:
                apiProxy = getClient().events();
                break;
            case FREEBUSY:
                apiProxy = getClient().freebusy();
                break;
            case SETTINGS:
                apiProxy = getClient().settings();
                break;
            default:
                throw new IllegalArgumentException("Invalid API name " + apiName);
        }
    }

    public String resolveStaticUri(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        String topic = parseTopicName(entry.getUri());
        if (topic != null) {
            String originalTopic = parseTopicName(entry.getOriginalUri());
            if (!topic.equals(originalTopic)) {
                 
                String answer = entry.getUri();
                answer = StringHelper.replaceFirst(answer, topic, originalTopic);
                return answer;
            }
        }
        return null;
    }

    public static KafkaResumeStrategyConfigurationBuilder newEmptyBuilder() {
        final Properties producerProperties = new Properties();
        final Properties consumerProperties = new Properties();

        KafkaResumeStrategyConfigurationBuilder builder = new KafkaResumeStrategyConfigurationBuilder(
                producerProperties,
                consumerProperties);

        String groupId = UUID.randomUUID().toString();
        LOG.debug("Creating consumer with {}[{}]", ConsumerConfig.GROUP_ID_CONFIG, groupId);
        builder.withGroupId(groupId);
        builder.withEnableAutoCommit(true);

        return builder;
    }

    protected List<Configurer<SSLSocket>> getSSLSocketFactorySSLSocketConfigurers(SSLContext context) {
        final List<String> enabledCipherSuites = this.getCipherSuites() == null
                ? null : this.parsePropertyValues(this.getCipherSuites().getCipherSuite());

        final Patterns enabledCipherSuitePatterns;
        final Patterns defaultEnabledCipherSuitePatterns = this.getDefaultCipherSuitesFilter().getPatterns();

        if (this.getCipherSuitesFilter() != null) {
            enabledCipherSuitePatterns = this.getCipherSuitesFilter().getPatterns();
        } else {
            enabledCipherSuitePatterns = null;
        }

        final List<String> enabledSecureSocketProtocols = this.getSecureSocketProtocols() == null
                ? null : this.parsePropertyValues(this.getSecureSocketProtocols().getSecureSocketProtocol());

        final Patterns enabledSecureSocketProtocolsPatterns;
        final Patterns defaultEnabledSecureSocketProtocolsPatterns = this.getDefaultSecureSocketProcotolFilter().getPatterns();

        if (this.getSecureSocketProtocolsFilter() != null) {
            enabledSecureSocketProtocolsPatterns = this.getSecureSocketProtocolsFilter().getPatterns();
        } else {
            enabledSecureSocketProtocolsPatterns = null;
        }

         

        final boolean allowPassthrough = getAllowPassthrough();

         

        Configurer<SSLSocket> sslSocketConfigurer = new Configurer<>() {

            @Override
            public SSLSocket configure(SSLSocket socket) {

                if (!getSNIHostNames().isEmpty()) {
                    SSLParameters sslParameters = socket.getSSLParameters();
                    sslParameters.setServerNames(getSNIHostNames());
                    socket.setSSLParameters(sslParameters);
                }

                Collection<String> filteredCipherSuites = BaseSSLContextParameters.this
                        .filter(enabledCipherSuites, Arrays.asList(socket.getSSLParameters().getCipherSuites()),
                                Arrays.asList(socket.getEnabledCipherSuites()),
                                enabledCipherSuitePatterns, defaultEnabledCipherSuitePatterns,
                                !allowPassthrough);
                if (LOG.isDebugEnabled()) {
                    LOG.debug(SSL_SOCKET_CIPHER_SUITE_LOG_MSG,
                            socket,
                            enabledCipherSuites,
                            enabledCipherSuitePatterns,
                            socket.getSSLParameters().getCipherSuites(),
                            socket.getEnabledCipherSuites(),
                            defaultEnabledCipherSuitePatterns,
                            filteredCipherSuites);
                }

                socket.setEnabledCipherSuites(filteredCipherSuites.toArray(new String[0]));

                Collection<String> filteredSecureSocketProtocols = BaseSSLContextParameters.this
                        .filter(enabledSecureSocketProtocols, Arrays.asList(socket.getSSLParameters().getProtocols()),
                                Arrays.asList(socket.getEnabledProtocols()),
                                enabledSecureSocketProtocolsPatterns, defaultEnabledSecureSocketProtocolsPatterns,
                                !allowPassthrough);

                if (LOG.isDebugEnabled()) {
                    LOG.debug(SSL_SOCKET_PROTOCOL_LOG_MSG,
                            socket,
                            enabledSecureSocketProtocols,
                            enabledSecureSocketProtocolsPatterns,
                            socket.getSSLParameters().getProtocols(),
                            socket.getEnabledProtocols(),
                            defaultEnabledSecureSocketProtocolsPatterns,
                            filteredSecureSocketProtocols);
                }

                socket.setEnabledProtocols(
                        filteredSecureSocketProtocols.toArray(new String[0]));
                return socket;
            }
        };

        List<Configurer<SSLSocket>> sslSocketConfigurers = new LinkedList<>();
        sslSocketConfigurers.add(sslSocketConfigurer);

        return sslSocketConfigurers;
    }

    public Optional<CamelClusterMember> getLeader() {
        if (this.cache == null) {
            return Optional.empty();
        }

        String id = cache.get(InfinispanClusterService.LEADER_KEY);
        if (id == null) {
            return Optional.empty();
        }

        return Optional.of(new ClusterMember(id));
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (vertx == null) {
            if (vertxOptions != null) {
                vertx = Vertx.vertx(vertxOptions);
            } else {
                vertx = Vertx.vertx();
            }
            managedVertx = true;
        }
    }

    public ProcessResponse cancelProcessInstance(ProcessRequest processMessage) {
        ProcessResponse resultMessage = new ProcessResponse();
        resultMessage.setProcessInstanceKey(processMessage.getProcessInstanceKey());

        try {
            GatewayGrpc.GatewayBlockingStub stub = GatewayGrpc.newBlockingStub(managedChannel);
            GatewayOuterClass.CancelProcessInstanceResponse cancelProcessInstanceResponse
                    = stub.cancelProcessInstance(GatewayOuterClass.CancelProcessInstanceRequest.newBuilder()
                            .setProcessInstanceKey(processMessage.getProcessInstanceKey())
                            .build());

            resultMessage.setSuccess(true);
        } catch (StatusRuntimeException exception) {
            LOG.error(String.format("Cannot cancel process instance %s", processMessage.getProcessId()), exception);
            resultMessage.setErrorMessage(exception.getMessage());
            resultMessage.setErrorCode(exception.getStatus().toString());
            resultMessage.setSuccess(false);
        }

        return resultMessage;
    }

    private SftpRemoteFile[] getSftpRemoteFiles(String dir) {
        SftpRemoteFile[] files = null;
        try {
            LOG.trace("Polling directory: {}", dir);
            if (isUseList()) {
                files = listFiles(dir);
            } else {
                files = pollNamedFile();
            }
        } catch (GenericFileOperationFailedException e) {
            if (ignoreCannotRetrieveFile(null, null, e)) {
                LOG.debug("Cannot list files in directory {} due directory does not exist or file permission error.", dir);
            } else {
                throw e;
            }
        }
        return files;
    }

    private static void resolveGistAsRawFiles(
            String url, StringJoiner routes, StringJoiner kamelets, StringJoiner properties, StringJoiner all)
            throws Exception {

         
        HttpClient hc = HttpClient.newHttpClient();
        HttpResponse<String> res = hc.send(HttpRequest.newBuilder(new URI(url)).timeout(Duration.ofSeconds(20)).build(),
                HttpResponse.BodyHandlers.ofString());

        if (res.statusCode() == 200) {
            ObjectMapper mapper = new ObjectMapper();
            JsonNode root = mapper.readTree(res.body());
            for (JsonNode c : root.get("files")) {
                String name = c.get("filename").asText();
                String ext = FileUtil.onlyExt(name, false);
                if (kamelets != null && "kamelet.yaml".equalsIgnoreCase(ext)) {
                    String rawUrl = c.get("raw_url").asText();
                    String u = asGistSingleUrl(rawUrl);
                    kamelets.add(u);
                } else if (properties != null && "properties".equalsIgnoreCase(ext)) {
                    String rawUrl = c.get("raw_url").asText();
                    String u = asGistSingleUrl(rawUrl);
                    properties.add(u);
                } else if (routes != null) {
                    if ("java".equalsIgnoreCase(ext) || "xml".equalsIgnoreCase(ext)
                            || "yaml".equalsIgnoreCase(ext) || "camel.yaml".equalsIgnoreCase(ext)) {
                        String rawUrl = c.get("raw_url").asText();
                        String u = asGistSingleUrl(rawUrl);
                        routes.add(u);
                    }
                } else if (all != null) {
                    String rawUrl = c.get("raw_url").asText();
                    String u = asGistSingleUrl(rawUrl);
                    all.add(u);
                }
            }
        }
    }

    void processCompositeResponseRaw(
            final Exchange exchange, final Optional<InputStream> responseBody, final Map<String, String> headers,
            final SalesforceException exception, final AsyncCallback callback) {
        try {
            if (!responseBody.isPresent()) {
                exchange.setException(exception);
            } else {
                final Message in = exchange.getIn();
                final Message out = exchange.getOut();

                final InputStream response = responseBody.get();

                out.copyFromWithNewBody(in, response);
                out.getHeaders().putAll(headers);
            }
        } finally {
             
            callback.done(false);
        }
    }

    protected Pattern createJsonMaskPattern(Set<String> keywords) {
        StringBuilder regex = createOneOfThemRegex(keywords);
        if (regex == null) {
            return null;
        }
        regex.insert(0, "\\\"(");
        regex.append(")\\\"(\\s*?):(\\s*?)\\\"([^\"]*)\\\"");

        if (LOG.isDebugEnabled()) {
            LOG.debug("JSon Pattern: {}", regex);
        }
        return Pattern.compile(regex.toString(), Pattern.CASE_INSENSITIVE);
    }

    public static URL resolveMandatoryResourceAsUrl(CamelContext camelContext, String uri)
            throws FileNotFoundException, MalformedURLException {
        URL url = resolveResourceAsUrl(camelContext, uri);
        if (url == null) {
            String resolvedName = resolveUriPath(uri);
            throw new FileNotFoundException("Cannot find resource: " + resolvedName + " in classpath for URI: " + uri);
        } else {
            return url;
        }
    }

    private static void configureHttpClientPolicy(
            ServiceNowConfiguration configuration, WebClient client) {

        HTTPClientPolicy httpPolicy = configuration.getHttpClientPolicy();
        if (httpPolicy == null) {
            String host = configuration.getProxyHost();
            Integer port = configuration.getProxyPort();

            if (host != null && port != null) {
                httpPolicy = new HTTPClientPolicy();
                httpPolicy.setProxyServer(host);
                httpPolicy.setProxyServerPort(port);
            }
        }

        if (httpPolicy != null) {
            WebClient.getConfig(client).getHttpConduit().setClient(httpPolicy);
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.aws.cloudtrail.lookupEvents");

        if (message.getHeaders().containsKey(CloudtrailConstants.EVENT_SOURCE)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "aws.cloudtrail.event.source." + message.getHeader(CloudtrailConstants.EVENT_SOURCE, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(CloudtrailConstants.EVENT_ID, String.class));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.TEXT_PLAIN_MIME_TYPE);
    }

    public Set<PosixFilePermission> getPermissions() {
        Set<PosixFilePermission> permissions = EnumSet.noneOf(PosixFilePermission.class);
        if (ObjectHelper.isEmpty(chmod)) {
            return permissions;
        }

        String chmodString = chmod.substring(chmod.length() - 3);  
                                                                  
                                                                  

        int ownerValue = Integer.parseInt(chmodString.substring(0, 1));
        int groupValue = Integer.parseInt(chmodString.substring(1, 2));
        int othersValue = Integer.parseInt(chmodString.substring(2, 3));

        if ((ownerValue & CHMOD_WRITE_MASK) > 0) {
            permissions.add(PosixFilePermission.OWNER_WRITE);
        }
        if ((ownerValue & CHMOD_READ_MASK) > 0) {
            permissions.add(PosixFilePermission.OWNER_READ);
        }
        if ((ownerValue & CHMOD_EXECUTE_MASK) > 0) {
            permissions.add(PosixFilePermission.OWNER_EXECUTE);
        }

        if ((groupValue & CHMOD_WRITE_MASK) > 0) {
            permissions.add(PosixFilePermission.GROUP_WRITE);
        }
        if ((groupValue & CHMOD_READ_MASK) > 0) {
            permissions.add(PosixFilePermission.GROUP_READ);
        }
        if ((groupValue & CHMOD_EXECUTE_MASK) > 0) {
            permissions.add(PosixFilePermission.GROUP_EXECUTE);
        }

         
        if ((othersValue & CHMOD_WRITE_MASK) > 0) {
            permissions.add(PosixFilePermission.OTHERS_WRITE);  
        }
        if ((othersValue & CHMOD_READ_MASK) > 0) {
            permissions.add(PosixFilePermission.OTHERS_READ);  
        }
        if ((othersValue & CHMOD_EXECUTE_MASK) > 0) {
            permissions.add(PosixFilePermission.OTHERS_EXECUTE);  
        }

        return permissions;
    }

    protected String populateContentOnMimeMessage(MimeMessage part, MailConfiguration configuration, Exchange exchange)
            throws MessagingException, IOException {

        String contentType = determineContentType(configuration, exchange);

        LOG.trace("Using Content-Type {} for MimeMessage: {}", contentType, part);

        String body = exchange.getIn().getBody(String.class);
        if (body == null) {
            body = "";
        }

         
        DataSource ds = new ByteArrayDataSource(body, contentType);
        part.setDataHandler(new DataHandler(ds));

         
        part.setHeader("Content-Type", contentType);

        return contentType;
    }

    private static void setAdditionalConfiguration(
            CamelContext camelContext, RestConfiguration config, DataFormat dataFormat, String prefix) {
        if (config.getDataFormatProperties() != null && !config.getDataFormatProperties().isEmpty()) {
             
             
            Map<String, Object> copy = new HashMap<>();

             
             
             
            for (Map.Entry<String, Object> entry : config.getDataFormatProperties().entrySet()) {
                String key = entry.getKey();
                String copyKey;
                boolean known = isKeyKnownPrefix(key);
                if (known) {
                     
                    copyKey = key.substring(prefix.length());
                } else {
                     
                    copyKey = key;
                }
                if (!known || key.startsWith(prefix)) {
                    copy.put(copyKey, entry.getValue());
                }
            }

            PropertyBindingSupport.build().bind(camelContext, dataFormat, copy);
        }
    }

    private ZipArchiveEntry getNextEntry() throws IOException {
        ZipArchiveEntry entry;

        while ((entry = zipInputStream.getNextEntry()) != null) {
            if (!entry.isDirectory()) {
                return entry;
            } else {
                if (allowEmptyDirectory) {
                    return entry;
                }
            }
        }

        return null;
    }

    public static SecretManagerServiceClient create(
            CamelContext context,
            GoogleSecretManagerConfiguration configuration)
            throws Exception {
        SecretManagerServiceClient secretManagerServiceClient = null;
        if (!Strings.isNullOrEmpty(configuration.getServiceAccountKey())) {
            InputStream resolveMandatoryResourceAsInputStream
                    = ResourceHelper.resolveMandatoryResourceAsInputStream(context, configuration.getServiceAccountKey());
            Credentials myCredentials = ServiceAccountCredentials
                    .fromStream(resolveMandatoryResourceAsInputStream);
            SecretManagerServiceSettings settings = SecretManagerServiceSettings.newBuilder()
                    .setCredentialsProvider(FixedCredentialsProvider.create(myCredentials)).build();
            secretManagerServiceClient = SecretManagerServiceClient.create(settings);
        } else {
             
             
             
            SecretManagerServiceSettings settings = SecretManagerServiceSettings.newBuilder().build();
            secretManagerServiceClient = SecretManagerServiceClient.create(settings);
        }
        return secretManagerServiceClient;
    }

    protected void afterConfigureProperties() {
        switch (apiName) {
            case LIST:
                apiProxy = getClient().calendarList();
                break;
            case ACL:
                apiProxy = getClient().acl();
                break;
            case CALENDARS:
                apiProxy = getClient().calendars();
                break;
            case CHANNELS:
                apiProxy = getClient().channels();
                break;
            case COLORS:
                apiProxy = getClient().colors();
                break;
            case EVENTS:
                apiProxy = getClient().events();
                break;
            case FREEBUSY:
                apiProxy = getClient().freebusy();
                break;
            case SETTINGS:
                apiProxy = getClient().settings();
                break;
            default:
                throw new IllegalArgumentException("Invalid API name " + apiName);
        }
    }

                public void artifactDownloaded(RepositoryEvent event) {
                    if (event.getArtifact() != null) {
                        Artifact a = event.getArtifact();

                        ArtifactRepository ar = event.getRepository();
                        String url = ar instanceof RemoteRepository ? ((RemoteRepository) ar).getUrl() : null;
                        String id = ar != null ? ar.getId() : null;
                        long elapsed = watch.takenAndRestart();
                        String version = a.isSnapshot() ? a.getBaseVersion() : a.getVersion();
                        remoteArtifactDownloadListener.artifactDownloaded(a.getGroupId(), a.getArtifactId(), version,
                                id, url, elapsed);
                    }
                }

                public void onFailure(Exchange exchange) {
                    final String key = exchange.getProperty(AWS2S3Constants.KEY, String.class);
                    try {
                        processRollback(exchange);
                    } finally {
                        if (key != null) {
                            getEndpoint().getInProgressRepository().remove(key);
                        }
                    }
                }

    private Map<String, String> getQueryMap(String query) {
        Map<String, String> map = new HashMap<>();
        if (query != null) {
            String[] params = query.split("&");
            for (String param : params) {
                String[] nameval = param.split("=");
                map.put(nameval[0], nameval[1]);
            }
        }
        return map;
    }

    private void attachVolumeToDroplet(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
        String volumeId = exchange.getIn().getHeader(DigitalOceanHeaders.ID, String.class);
        String volumeName = exchange.getIn().getHeader(DigitalOceanHeaders.VOLUME_NAME, String.class);
        Integer dropletId = exchange.getIn().getHeader(DigitalOceanHeaders.DROPLET_ID, Integer.class);
        String region = exchange.getIn().getHeader(DigitalOceanHeaders.REGION, String.class);

        if (ObjectHelper.isEmpty(dropletId)) {
            throw new IllegalArgumentException(DigitalOceanHeaders.DROPLET_ID + " must be specified");
        }

        if (ObjectHelper.isEmpty(region)) {
            throw new IllegalArgumentException(DigitalOceanHeaders.REGION + " must be specified");
        }

        Action action;

        if (ObjectHelper.isNotEmpty(volumeName)) {
            action = getEndpoint().getDigitalOceanClient().attachVolumeByName(dropletId, volumeName, region);
            LOG.trace("Attach Volume {} to Droplet {} [{}] ", volumeName, dropletId, action);
        } else if (ObjectHelper.isNotEmpty(volumeId)) {
            action = getEndpoint().getDigitalOceanClient().attachVolume(dropletId, volumeId, region);
            LOG.trace("Attach Volume {} to Droplet {} [{}] ", volumeId, dropletId, action);
        } else {
            throw new IllegalArgumentException(
                    DigitalOceanHeaders.ID + " or " + DigitalOceanHeaders.VOLUME_NAME + " must be specified");
        }

        exchange.getMessage().setBody(action);
    }

    public int processBatch(Queue<Object> exchanges) throws Exception {
        int total = exchanges.size();

        for (int index = 0; index < total && isBatchAllowed(); index++) {
             
            final Exchange exchange = ObjectHelper.cast(Exchange.class, exchanges.poll());
             
            exchange.setProperty(ExchangePropertyKey.BATCH_INDEX, index);
            exchange.setProperty(ExchangePropertyKey.BATCH_SIZE, total);
            exchange.setProperty(ExchangePropertyKey.BATCH_COMPLETE, index == total - 1);

             
            pendingExchanges = total - index - 1;

             
            AsyncCallback cb = defaultConsumerCallback(exchange, true);
            getAsyncProcessor().process(exchange, cb);
        }

        return total;
    }

    private void refreshStatusLosingLeadership() {
         
        long delay = this.lockConfiguration.getLeaseDurationMillis();
        LOG.info("{} Current pod owns the leadership, but it will be lost in {} seconds...", logPrefix,
                new BigDecimal(delay).divide(BigDecimal.valueOf(1000), 2, RoundingMode.HALF_UP));

        try {
            Thread.sleep(delay);
        } catch (InterruptedException e) {
            LOG.warn("Thread interrupted", e);
            Thread.currentThread().interrupt();
        }

        LOG.info("{} Current pod is losing leadership now...", logPrefix);
        this.currentState = State.LEADERSHIP_LOST;
        this.serializedExecutor.execute(this::refreshStatus);
    }

    private void stopConsumer(Route route) {
        lock.lock();
        try {
            if (!suspendedRoutes.contains(route)) {
                LOGGER.debug("Stopping consumer for {} ({})", route.getId(), route.getConsumer());
                stopConsumer(route.getConsumer());
                suspendedRoutes.add(route);
            }
        } catch (Exception e) {
            handleException(e);
        } finally {
            lock.unlock();
        }
    }

    public <T> Set<T> findByType(Class<T> type) {
        String keyPrefix = type.getName().replace('$', '/');
        Set<T> result = new HashSet<>();

        List<String> keys;
        try {
            keys = kvClient.getKeys(keyPrefix);
        } catch (ConsulException e) {
            return result;
        }

        if (keys != null) {
            Object obj;

            for (String key : keys) {
                 
                key = key.substring(key.lastIndexOf('/') + 1);
                obj = lookupByName(key.replace('$', '/'));
                if (type.isInstance(obj)) {
                    result.add(type.cast(obj));
                }
            }
        }
        return result;
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();
        if (propertiesFunction != null) {
            root.put("login", "Client Id/Client Secret");
            AzureVaultConfiguration azure = getCamelContext().getVaultConfiguration().getAzureVaultConfiguration();
            if (azure != null) {
                root.put("refreshEnabled", azure.isRefreshEnabled());
                root.put("refreshPeriod", azure.getRefreshPeriod());
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastCheckTimestamp", timestamp);
                    root.put("lastCheckAge", TimeUtils.printSince(timestamp));
                }
                last = secretsRefreshTask.getLastReloadTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastReloadTimestamp", timestamp);
                    root.put("lastReloadAge", TimeUtils.printSince(timestamp));
                }
            }
            JsonArray arr = new JsonArray();
            root.put("secrets", arr);

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                JsonObject jo = new JsonObject();
                jo.put("name", sec);
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    jo.put("timestamp", timestamp);
                    jo.put("age", TimeUtils.printSince(timestamp));
                }
                arr.add(jo);
            }
        }
        return root;
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (requestClass.isInstance(payload)) {
                try {
                    result = pojoExecutor.apply(requestClass.cast(payload));
                } catch (AwsServiceException ase) {
                    LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            } else {
                throw new IllegalArgumentException(
                        String.format("Expected body of type %s but was %s",
                                requestClass.getName(),
                                payload != null ? payload.getClass().getName() : "null"));
            }
        } else {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    private static void baseToJson(BaseModel<?> model, JsonObject obj) {
        obj.put("kind", model.getKind());
        obj.put("name", model.getName());
        obj.put("title", model.getTitle());
        obj.put("description", model.getDescription());
        obj.put("deprecated", model.isDeprecated());
        obj.put("deprecatedSince", model.getDeprecatedSince());
        obj.put("deprecationNote", model.getDeprecationNote());
        obj.put("firstVersion", model.getFirstVersion());
        obj.put("label", model.getLabel());
        obj.put("javaType", model.getJavaType());
        if (model.getSupportLevel() != null) {
            obj.put("supportLevel", model.getSupportLevel().name());
        }
        if (model.isNativeSupported()) {
            obj.put("nativeSupported", model.isNativeSupported());
        }
        if (!model.getMetadata().isEmpty()) {
            obj.put("metadata", model.getMetadata());
        }
    }

    protected Class<?> getRequestModel(Message message, String modelName) {
        Class<?> model = null;

        if (message != null) {
            model = message.getHeader(ServiceNowConstants.REQUEST_MODEL, Class.class);
            if (model == null) {
                model = message.getHeader(ServiceNowConstants.MODEL, Class.class);
            }
        }

        return model != null
                ? model
                : ObjectHelper.isEmpty(modelName) ? Map.class : config.getRequestModel(modelName, Map.class);
    }

    private void processGetBatch(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String jobId;
        BatchInfo batchBody = exchange.getIn().getBody(BatchInfo.class);
        String batchId;
        if (batchBody != null) {
            jobId = batchBody.getJobId();
            batchId = batchBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
            batchId = getParameter(BATCH_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getBatch(jobId, batchId, determineHeaders(exchange), new BulkApiClient.BatchInfoResponseCallback() {
            @Override
            public void onResponse(BatchInfo batchInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, batchInfo, headers, ex, callback);
            }
        });
    }

    public V put(K key, V value, long timeoutMillis) {
        TimeoutMapEntry<K, V> entry = new TimeoutMapEntry<>(key, value, timeoutMillis);
        lock.lock();
        try {
            updateExpireTime(entry);
            TimeoutMapEntry<K, V> result = map.put(key, entry);
            return unwrap(result);
        } finally {
            lock.unlock();
            emitEvent(Put, key, value);
        }
    }

    public <T extends Enum<T>> T getEnumOrDefault(final String key, final T defaultValue) throws ClassNotFoundException {
         
        T returnable;
        final String value;
        final String[] splitValues;
        final int numberOfSplitValues;
        final StringBuilder returnTypeName;
        final StringBuilder enumName;
        final Class<T> returnType;
         
        if (this.containsKey(key)) {
             
            value = this.getStringOrDefault(key, "");
            if (value == null) {
                return null;
            }
             
            splitValues = value.split("\\.");
            numberOfSplitValues = splitValues.length;
            returnTypeName = new StringBuilder();
            enumName = new StringBuilder();
            for (int i = 0; i < numberOfSplitValues; i++) {
                if (i == (numberOfSplitValues - 1)) {
                     
                    enumName.append(splitValues[i]);
                } else if (i == (numberOfSplitValues - 2)) {
                     
                    returnTypeName.append(splitValues[i]);
                } else {
                     
                    returnTypeName.append(splitValues[i]);
                    returnTypeName.append(".");
                }
            }
             
            returnType = (Class<T>) Class.forName(returnTypeName.toString());
            returnable = Enum.valueOf(returnType, enumName.toString());
        } else {
             
            return defaultValue;
        }
        return returnable;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        JCacheConfiguration configuration = new JCacheConfiguration(getCamelContext(), remaining);

        configuration.setCachingProvider(cachingProvider);
        configuration.setCacheConfiguration(cacheConfiguration);
        configuration.setCacheConfigurationProperties(loadProperties());
        configuration.setConfigurationUri(configurationUri);

        JCacheEndpoint endpoint = new JCacheEndpoint(uri, this, configuration);
        setProperties(endpoint, parameters);
        return endpoint;
    }

    public String resolveStaticUri(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        String destination = parseTopicName(entry.getUri());
        if (destination != null) {
            String originalDestination = parseTopicName(entry.getOriginalUri());
            if (!destination.equals(originalDestination)) {
                 
                String answer = entry.getUri();
                answer = StringHelper.replaceFirst(answer, destination, originalDestination);
                return answer;
            }
        }
        return null;
    }

        protected void purge() {
             
            if (lock != null) {
                 
                lock.lock();
                try {
                    super.purge();
                } finally {
                    lock.unlock();
                }
            }
        }

    private WatsonTextToSpeechOperations determineOperation(Exchange exchange) {
        WatsonTextToSpeechOperations operation
                = exchange.getIn().getHeader(WatsonTextToSpeechConstants.OPERATION, WatsonTextToSpeechOperations.class);

        if (operation == null) {
            operation = getEndpoint().getConfiguration().getOperation();
        }

        if (operation == null) {
            throw new IllegalArgumentException("Operation must be specified");
        }

        return operation;
    }

    private static GenericFileExclusiveReadLockStrategy<File> newStrategyForIdempotentChanged(
            Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<File> strategy;
        FileIdempotentChangedRepositoryReadLockStrategy readLockStrategy
                = new FileIdempotentChangedRepositoryReadLockStrategy();
        Boolean readLockRemoveOnRollback = (Boolean) params.get("readLockRemoveOnRollback");
        if (readLockRemoveOnRollback != null) {
            readLockStrategy.setRemoveOnRollback(readLockRemoveOnRollback);
        }
        Boolean readLockRemoveOnCommit = (Boolean) params.get("readLockRemoveOnCommit");
        if (readLockRemoveOnCommit != null) {
            readLockStrategy.setRemoveOnCommit(readLockRemoveOnCommit);
        }
        IdempotentRepository repo = (IdempotentRepository) params.get("readLockIdempotentRepository");
        if (repo != null) {
            readLockStrategy.setIdempotentRepository(repo);
        }
        Long minLength = (Long) params.get("readLockMinLength");
        if (minLength != null) {
            readLockStrategy.setMinLength(minLength);
        }
        Long minAge = (Long) params.get("readLockMinAge");
        if (null != minAge) {
            readLockStrategy.setMinAge(minAge);
        }
        Integer readLockIdempotentReleaseDelay = (Integer) params.get("readLockIdempotentReleaseDelay");
        if (readLockIdempotentReleaseDelay != null) {
            readLockStrategy.setReadLockIdempotentReleaseDelay(readLockIdempotentReleaseDelay);
        }
        Boolean readLockIdempotentReleaseAsync = (Boolean) params.get("readLockIdempotentReleaseAsync");
        if (readLockIdempotentReleaseAsync != null) {
            readLockStrategy.setReadLockIdempotentReleaseAsync(readLockIdempotentReleaseAsync);
        }
        Integer readLockIdempotentReleaseAsyncPoolSize = (Integer) params.get("readLockIdempotentReleaseAsyncPoolSize");
        if (readLockIdempotentReleaseAsyncPoolSize != null) {
            readLockStrategy.setReadLockIdempotentReleaseAsyncPoolSize(readLockIdempotentReleaseAsyncPoolSize);
        }
        ScheduledExecutorService readLockIdempotentReleaseExecutorService
                = (ScheduledExecutorService) params.get("readLockIdempotentReleaseExecutorService");
        if (readLockIdempotentReleaseExecutorService != null) {
            readLockStrategy.setReadLockIdempotentReleaseExecutorService(readLockIdempotentReleaseExecutorService);
        }
        strategy = readLockStrategy;
        return strategy;
    }

    public Integer doCall() throws Exception {
        List<Long> pids = findPids(name);
        for (long pid : pids) {
            JsonObject root = new JsonObject();
            root.put("action", "reload");
            Path f = getActionFile(Long.toString(pid));
            Files.writeString(f, root.toJson());
        }

        return 0;
    }

    private int readTraceFiles(Map<Long, Pid> pids) throws Exception {
        int lines = 0;

        for (Pid pid : pids.values()) {
            if (pid.reader == null) {
                Path file = getTraceFile(pid.pid);
                if (Files.exists(file)) {
                    pid.reader = new LineNumberReader(Files.newBufferedReader(file));
                    if (tail == 0) {
                         
                        long size = Files.size(file);
                        pid.reader.skip(size);
                    }
                }
            }
            if (pid.reader != null) {
                String line;
                do {
                    try {
                        line = pid.reader.readLine();
                        if (line != null) {
                            lines++;
                             
                            if (pid.fifo == null || pid.fifo instanceof ArrayBlockingQueue) {
                                pid.fifo = new ArrayDeque<>();
                            }
                            pid.fifo.offer(line);
                        }
                    } catch (IOException e) {
                         
                        line = null;
                    }
                } while (line != null);
            }
        }

        return lines;
    }

    public Edm getEdm(Map<String, String> endpointHttpHeaders) throws RuntimeCamelException {
        Edm localEdm = edm;
        if (localEdm == null) {
            lock.lock();
            try {

                localEdm = edm;
                if (localEdm == null) {

                    final CountDownLatch latch = new CountDownLatch(1);
                    final Exception[] error = new Exception[1];
                    olingo2App.read(null, "$metadata", null, endpointHttpHeaders, new Olingo2ResponseHandler<Edm>() {

                        @Override
                        public void onResponse(Edm response, Map<String, String> responseHeaders) {
                            edm = response;
                            latch.countDown();
                        }

                        @Override
                        public void onException(Exception ex) {
                            error[0] = ex;
                            latch.countDown();
                        }

                        @Override
                        public void onCanceled() {
                            error[0] = new RuntimeCamelException("OData HTTP request cancelled!");
                            latch.countDown();
                        }
                    });

                    try {
                         
                        latch.await();

                        final Exception ex = error[0];
                        if (ex != null) {
                            if (ex instanceof RuntimeCamelException) {
                                throw (RuntimeCamelException) ex;
                            } else {
                                final String message = ex.getMessage() != null ? ex.getMessage() : ex.getClass().getName();
                                throw new RuntimeCamelException("Error reading EDM: " + message, ex);
                            }
                        }

                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        throw new RuntimeCamelException(e.getMessage(), e);
                    }

                    localEdm = edm;
                }
            } finally {
                lock.unlock();
            }
        }

        return localEdm;
    }

    protected void handleReplyMessage(String correlationID, Message message, Session session) {
        ReplyHandler handler = correlation.remove(correlationID);
        if (handler == null && endpoint.isUseMessageIDAsCorrelationID()) {
            handler = waitForProvisionCorrelationToBeUpdated(correlationID, message);
        }

        if (handler != null) {
            handler.onReply(correlationID, message, session);
        } else {
             
             
             
            log.warn("Reply received for unknown correlationID [{}]. The message will be ignored: {}", correlationID, message);
        }
    }

    private <T> void subscribeToMono(
            final Mono<T> inputMono, final Exchange exchange, final Consumer<T> resultsCallback, final AsyncCallback callback) {
        inputMono
                .subscribe(resultsCallback, error -> {
                     
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("Error processing async exchange with error: {}", error.getMessage());
                    }
                    exchange.setException(error);
                    callback.done(false);
                }, () -> {
                     
                    LOG.trace("All events with exchange have been sent successfully.");
                    callback.done(false);
                });
    }

    public void process(Exchange exchange) {
        var context = exchange.getContext();
        var msg = exchange.getMessage();

        logRequestHeaders(procName, msg);

         
         
        var oauth = findOAuth(context).orElseGet(() -> {
            var factory = OAuthFactory.lookupFactory(context);
            return factory.createOAuth();
        });

         
         
        var session = oauth.getOrCreateSession(exchange);

         
         
        if (session.getUserProfile().isPresent()) {
            var userProfile = session.removeUserProfile().orElseThrow();
            try {
                userProfile = authenticateExistingUserProfile(oauth, userProfile);
                session.putUserProfile(userProfile);
                return;
            } catch (OAuthException ex) {
                log.error("Failed to authenticate: {}", userProfile.subject(), ex);
            }
        }

         
         
        var postLoginUrl = getPostLoginUrl(msg);
        log.info("Register post login url: {}", postLoginUrl);
        session.putValue("OAuthPostLoginUrl", postLoginUrl);

        var redirectUri = getRequiredProperty(exchange.getContext(), CAMEL_OAUTH_REDIRECT_URI);
        var params = new OAuthCodeFlowParams().setRedirectUri(redirectUri);
        var authRequestUrl = oauth.buildCodeFlowAuthRequestUrl(params);

        sendRedirect(msg, authRequestUrl);
    }

    protected void setupVmProtocol() {
        boolean minaLogger = configuration.isMinaLogger();
        List<IoFilter> filters = configuration.getFilters();

        address = new VmPipeAddress(configuration.getPort());
        connector = new VmPipeConnector();

         
        if (minaLogger) {
            connector.getFilterChain().addLast("logger", new LoggingFilter());
        }
        appendIoFiltersToChain(filters, connector.getFilterChain());
        if (configuration.getSslContextParameters() != null) {
            LOG.warn("Using vm protocol"
                     + ", but an SSLContextParameters instance was provided.  SSLContextParameters is only supported on the TCP protocol.");
        }
        configureCodecFactory("MinaProducer", connector);
    }

    private Object getValue(final Message message, final String type) throws Exception {
        Object value = message.getHeader(CaffeineConstants.VALUE);
        if (value == null) {
            if (type != null) {
                Class<?> clazz = getEndpoint().getCamelContext().getClassResolver().resolveClass(type);
                value = message.getBody(clazz);
            } else {
                value = message.getBody();
            }
        }

        if (value == null) {
            throw new CamelExchangeException(
                    "No value provided in header or body (" + CaffeineConstants.VALUE + ")", message.getExchange());
        }

        return value;
    }

    private void createCollection(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();

        String collectionName;
        if (in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class) != null) {
            collectionName = in.getHeader(WeaviateVectorDbHeaders.COLLECTION_NAME, String.class);
        } else {
            collectionName = getEndpoint().getCollection();
        }

        WeaviateClass collection = WeaviateClass.builder().className(collectionName).build();

        Result<Boolean> res = client.misc().readyChecker().run();

        Result<Boolean> result = client.schema().classCreator().withClass(collection).run();
        populateResponse(result, exchange);

    }

        boolean executeFromQueue() {
            final Runnable polled = queue != null ? queue.pollFirst() : null;
            if (polled == null) {
                return false;
            }
            try {
                decrementPendingTasks();
                if (LOG.isTraceEnabled()) {
                    LOG.trace("Running: {}", polled);
                }
                polled.run();
            } catch (Exception t) {
                 
                LOG.warn("Error executing reactive work due to {}. This exception is ignored.", t.getMessage(), t);
            }
            return true;
        }

    private void processStreamingRequest(
            InvokeModelWithResponseStreamRequest request,
            Exchange exchange) {

        try {
            String streamOutputMode = getConfiguration().getStreamOutputMode();
            if (streamOutputMode == null) {
                streamOutputMode = "complete";
            }

             
            if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockConstants.STREAM_OUTPUT_MODE))) {
                streamOutputMode = exchange.getIn().getHeader(BedrockConstants.STREAM_OUTPUT_MODE, String.class);
            }

            Message message = getMessageForResponse(exchange);
            BedrockStreamHandler.StreamMetadata metadata = new BedrockStreamHandler.StreamMetadata();

            if ("chunks".equals(streamOutputMode)) {
                 
                List<String> allChunks = new ArrayList<>();
                getEndpoint().getBedrockRuntimeAsyncClient().invokeModelWithResponseStream(
                        request,
                        BedrockStreamHandler.createChunksHandler(
                                getConfiguration().getModelId(),
                                metadata,
                                allChunks,
                                null))
                        .join();

                message.setBody(allChunks);
                if (getConfiguration().isIncludeStreamingMetadata()) {
                    setStreamingMetadata(message, metadata);
                }
            } else {
                 
                StringBuilder fullText = new StringBuilder();
                getEndpoint().getBedrockRuntimeAsyncClient().invokeModelWithResponseStream(
                        request,
                        BedrockStreamHandler.createCompleteHandler(
                                getConfiguration().getModelId(),
                                metadata,
                                fullText))
                        .join();

                message.setBody(fullText.toString());
                if (getConfiguration().isIncludeStreamingMetadata()) {
                    setStreamingMetadata(message, metadata);
                }
            }

        } catch (AwsServiceException ase) {
            LOG.trace("Invoke Model Streaming command returned the error code {}", ase.awsErrorDetails().errorCode());
            throw ase;
        }
    }

                public void eventReceived(Action action, ConfigMap resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

    public <T> void read(
            final Edm edm, final String resourcePath, final Map<String, String> queryParams,
            final Map<String, String> endpointHttpHeaders,
            final Olingo2ResponseHandler<T> responseHandler) {

        final UriInfoWithType uriInfo = parseUri(edm, resourcePath, queryParams);

        execute(new HttpGet(createUri(resourcePath, encodeQueryParams(queryParams))), getResourceContentType(uriInfo),
                endpointHttpHeaders,
                new AbstractFutureCallback<T>(responseHandler) {

                    @Override
                    public void onCompleted(HttpResponse result) throws IOException {
                        readContent(uriInfo, headersToMap(result.getAllHeaders()),
                                result.getEntity() != null ? result.getEntity().getContent() : null, responseHandler);
                    }

                });
    }

    public Object sendBodyAndHeader(
            String endpoint, ExchangePattern pattern, final Object body,
            final String header, final Object headerValue)
            throws CamelExecutionException {
        Exchange exchange = send(endpoint, pattern, createBodyAndHeaderProcessor(body, header, headerValue));
        Object result = extractResultBody(exchange, pattern);
        if (pattern == ExchangePattern.InOnly) {
             
            return null;
        } else {
            return result;
        }
    }

    public String summaryErrorMessage(boolean includeHeader, boolean ignoreDeprecated, boolean includeWarnings) {
        boolean ok = isSuccess();

         
        if (ok && !ignoreDeprecated) {
            ok = deprecated == null;
        }

        if (includeWarnings) {
            if (incapable != null) {
                return "\tIncapable of parsing uri: " + incapable;
            } else if (syntaxError != null) {
                return "\tSyntax error: " + syntaxError;
            } else if (unknownComponent != null) {
                return "\tUnknown component: " + unknownComponent;
            }
        }

        if (ok) {
            return null;
        }

         
        Map<String, String> options = new LinkedHashMap<>();
        if (unknown != null) {
            for (String name : unknown) {
                if (unknownSuggestions != null && unknownSuggestions.containsKey(name)) {
                    String[] suggestions = unknownSuggestions.get(name);
                    if (suggestions != null && suggestions.length > 0) {
                        String str = Arrays.asList(suggestions).toString();
                        options.put(name, "Unknown option. Did you mean: " + str);
                    } else {
                        options.put(name, "Unknown option");
                    }
                } else {
                    options.put(name, "Unknown option");
                }
            }
        }
        if (notConsumerOnly != null) {
            for (String name : notConsumerOnly) {
                options.put(name, "Option not applicable in consumer only mode");
            }
        }
        if (notProducerOnly != null) {
            for (String name : notProducerOnly) {
                options.put(name, "Option not applicable in producer only mode");
            }
        }
        if (required != null) {
            for (String name : required) {
                options.put(name, "Missing required option");
            }
        }
        if (deprecated != null) {
            for (String name : deprecated) {
                options.put(name, "Deprecated option");
            }
        }
        if (invalidEnum != null) {
            for (Map.Entry<String, String> entry : invalidEnum.entrySet()) {
                String name = entry.getKey();
                String[] choices = invalidEnumChoices.get(name);
                String defaultValue = defaultValues != null ? defaultValues.get(entry.getKey()) : null;
                String str = Arrays.asList(choices).toString();
                String msg = "Invalid enum value: " + entry.getValue() + ". Possible values: " + str;
                if (invalidEnumSuggestions != null) {
                    String[] suggestions = invalidEnumSuggestions.get(name);
                    if (suggestions != null && suggestions.length > 0) {
                        str = Arrays.asList(suggestions).toString();
                        msg += ". Did you mean: " + str;
                    }
                }
                if (defaultValue != null) {
                    msg += ". Default value: " + defaultValue;
                }

                options.put(entry.getKey(), msg);
            }
        }
        if (invalidReference != null) {
            for (Map.Entry<String, String> entry : invalidReference.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty reference value");
                } else if (!entry.getValue().startsWith("#")) {
                    options.put(entry.getKey(), "Invalid reference value: " + entry.getValue() + " must start with #");
                } else {
                    options.put(entry.getKey(), "Invalid reference value: " + entry.getValue());
                }
            }
        }
        if (invalidBoolean != null) {
            for (Map.Entry<String, String> entry : invalidBoolean.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty boolean value");
                } else {
                    options.put(entry.getKey(), "Invalid boolean value: " + entry.getValue());
                }
            }
        }
        if (invalidInteger != null) {
            for (Map.Entry<String, String> entry : invalidInteger.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty integer value");
                } else {
                    options.put(entry.getKey(), "Invalid integer value: " + entry.getValue());
                }
            }
        }
        if (invalidNumber != null) {
            for (Map.Entry<String, String> entry : invalidNumber.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty number value");
                } else {
                    options.put(entry.getKey(), "Invalid number value: " + entry.getValue());
                }
            }
        }

         
         
        int maxLen = 24;
        for (String key : options.keySet()) {
            maxLen = Math.max(maxLen, key.length());
        }
        String format = "%" + maxLen + "s    %s";

         
        StringBuilder sb = new StringBuilder(512);
        if (includeHeader) {
            sb.append("Endpoint validator error\n");
            sb.append(
                    "---------------------------------------------------------------------------------------------------------------------------------------\n");
            sb.append("\n");
        }
        if (uri != null) {
            sb.append("\t").append(uri).append("\n");
        } else {
            sb.append("\n");
        }
        for (Map.Entry<String, String> option : options.entrySet()) {
            String out = String.format(format, option.getKey(), option.getValue());
            sb.append("\n\t").append(out);
        }

        return sb.toString();
    }

    public Integer doCall() throws Exception {
        List<Long> pids = findPids(name);

        for (long pid : pids) {
            JsonObject root = new JsonObject();
            root.put("action", "processor");
            root.put("id", id);
            Path f = getActionFile(Long.toString(pid));
            onAction(root);
            PathUtils.writeTextSafely(root.toJson(), f);
        }

        return 0;
    }

    private void doDeleteList(Exchange exchange, SqlSession session) {
        Object result;
        Object in = getInput(exchange);
        if (in != null) {
             
            LOG.trace("Deleting: {} using statement: {}", in, statement);
            result = session.delete(statement, in);
            doProcessResult(exchange, result, session);
        } else {
            LOG.trace("Deleting using statement: {}", statement);
            result = session.delete(statement);
            doProcessResult(exchange, result, session);
        }
    }

    public Gmail makeClient(
            String clientId, String clientSecret, Collection<String> scopes, String applicationName, String refreshToken,
            String accessToken) {
        if (clientId == null || clientSecret == null) {
            throw new IllegalArgumentException("clientId and clientSecret are required to create Gmail client.");
        }
        try {
            Credential credential = authorize(clientId, clientSecret);

            if (refreshToken != null && !refreshToken.isEmpty()) {
                credential.setRefreshToken(refreshToken);
            }
            if (accessToken != null && !accessToken.isEmpty()) {
                credential.setAccessToken(accessToken);
            }
            return new Gmail.Builder(transport, jsonFactory, credential).setApplicationName(applicationName).build();
        } catch (Exception e) {
            throw new RuntimeCamelException("Could not create Gmail client.", e);
        }
    }

    protected void doGetDeployment(Exchange exchange) {
        String deploymentName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_DEPLOYMENT_NAME, String.class);
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        if (ObjectHelper.isEmpty(deploymentName)) {
            LOG.error("Get a specific Deployment require specify a Deployment name");
            throw new IllegalArgumentException("Get a specific Deployment require specify a Deployment name");
        }
        Deployment deployment;
        if (ObjectHelper.isNotEmpty(namespace)) {
            deployment = getEndpoint().getKubernetesClient().apps().deployments()
                    .inNamespace(namespace).withName(deploymentName).get();
        } else {
            deployment = getEndpoint().getKubernetesClient().apps().deployments().withName(deploymentName).get();
        }

        prepareOutboundMessage(exchange, deployment);
    }

    public PathHandler removePrefixPath(final String path) {
        lock.lock();
        try {
            super.removePrefixPath(path);
            handlers.remove(path);
            handlerString = null;
            return this;
        } finally {
            lock.unlock();
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
             
            for (Map.Entry<AsyncProcessor, Predicate> entry : methods.entrySet()) {
                Predicate predicate = entry.getValue();
                if (predicate.matches(exchange)) {
                    return entry.getKey().process(exchange, callback);
                }
            }
        } catch (Exception e) {
            exchange.setException(e);
        }
        callback.done(true);
        return true;
    }

    public RestDefinition clientResponseValidation(boolean clientResponseValidation) {
        if (getVerbs().isEmpty()) {
            this.clientResponseValidation = Boolean.toString(clientResponseValidation);
        } else {
             
            VerbDefinition verb = getVerbs().get(getVerbs().size() - 1);
            verb.setClientResponseValidation(Boolean.toString(clientResponseValidation));
        }

        return this;
    }

    public BigDecimal getBigDecimalOrDefault(final String key, final BigDecimal defaultValue) {
        Object returnable;
        if (this.containsKey(key)) {
            returnable = this.get(key);
        } else {
            return defaultValue;
        }
        if (returnable instanceof BigDecimal) {
             
        } else if (returnable instanceof Number) {
             
            returnable = new BigDecimal(returnable.toString());
        } else if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return (BigDecimal) returnable;
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.aws.s3.getObject");

        if (message.getHeaders().containsKey(AWS2S3Constants.BUCKET_NAME)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "aws.s3.bucket." + message.getHeader(AWS2S3Constants.BUCKET_NAME, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(AWS2S3Constants.KEY, String.class));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    public static boolean isBoundaryCloseDelimiter(final CharArrayBuffer buffer, ParserCursor cursor, String boundary) {
        ObjectHelper.notNull(buffer, "Buffer");
        ObjectHelper.notNull(boundary, "Boundary");

        String boundaryCloseDelimiter = "--" + boundary + "--";  
         
         
         

        if (cursor == null) {
            cursor = new ParserCursor(0, boundaryCloseDelimiter.length());
        }

        int indexFrom = cursor.getPos();
        int indexTo = cursor.getUpperBound();

        if ((indexFrom + boundaryCloseDelimiter.length()) > indexTo) {
            return false;
        }

        for (int i = indexFrom; i < indexTo; ++i) {
            if (buffer.charAt(i) != boundaryCloseDelimiter.charAt(i)) {
                return false;
            }
        }

        return true;
    }

    public HttpBinding getHttpBinding() {
         
        if (this.binding == null) {
            this.binding = new AttachmentHttpBinding();
            this.binding.setTransferException(isTransferException());
            this.binding.setMuteException(isMuteException());
            this.binding.setLogException(isLogException());
            if (getComponent() != null) {
                this.binding.setAllowJavaSerializedObject(getComponent().isAllowJavaSerializedObject());
            }
            this.binding.setHeaderFilterStrategy(getHeaderFilterStrategy());
            this.binding.setEagerCheckContentAvailable(isEagerCheckContentAvailable());
            this.binding.setMapHttpMessageBody(isMapHttpMessageBody());
            this.binding.setMapHttpMessageHeaders(isMapHttpMessageHeaders());
            this.binding.setMapHttpMessageFormUrlEncodedBody(isMapHttpMessageFormUrlEncodedBody());
        }
        return this.binding;
    }

    private void processAbortJob(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        JobInfo jobBody;
        String jobId;
        jobBody = exchange.getIn().getBody(JobInfo.class);
        if (jobBody != null) {
            jobId = jobBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.abortJob(jobId, determineHeaders(exchange), new BulkApiClient.JobInfoResponseCallback() {
            @Override
            public void onResponse(JobInfo jobInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, jobInfo, headers, ex, callback);
            }
        });
    }

    protected RouteTemplateDefinition createRouteTemplate() {
        RouteTemplateDefinition template = new RouteTemplateDefinition();
        ErrorHandlerFactory handler = getErrorHandlerFactory();
        if (handler != null) {
            template.getRoute().setErrorHandlerFactoryIfNull(handler);
        }
        if (resource != null) {
            template.setResource(resource);
        }
        return template;
    }

    private void createBuildGradle(Path settings, Path gradleBuild, Set<String> deps) throws Exception {
        String[] ids = gav.split(":");

        String context = readResourceTemplate("templates/spring-boot-build-gradle.tmpl");

        Properties prop = new CamelCaseOrderedProperties();
        RuntimeUtil.loadProperties(prop, settings);
        String repos = getMavenRepositories(settings, prop, camelSpringBootVersion);

        CamelCatalog catalog = CatalogLoader.loadSpringBootCatalog(repos, camelSpringBootVersion, download);
        String camelVersion = catalog.getLoadedVersion();

        context = context.replaceFirst("\\{\\{ \\.GroupId }}", ids[0]);
        context = context.replaceFirst("\\{\\{ \\.ArtifactId }}", ids[1]);
        context = context.replaceFirst("\\{\\{ \\.Version }}", ids[2]);
        context = context.replaceAll("\\{\\{ \\.SpringBootVersion }}", springBootVersion);
        context = context.replaceFirst("\\{\\{ \\.JavaVersion }}", javaVersion);
        context = context.replaceAll("\\{\\{ \\.CamelVersion }}", camelVersion);
        context = context.replaceFirst("\\{\\{ \\.CamelSpringBootVersion }}",
                Objects.requireNonNullElse(camelSpringBootVersion, camelVersion));

        if (repos == null || repos.isEmpty()) {
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", "");
        } else {
            StringBuilder sb = new StringBuilder();
            for (String repo : repos.split(",")) {
                sb.append("    maven {\n");
                sb.append("        url '").append(repo).append("'\n");
                if (repo.contains("snapshots")) {
                    sb.append("        mavenContent {\n");
                    sb.append("            snapshotsOnly()\n");
                    sb.append("        }\n");
                }
                sb.append("    }\n");
            }
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", sb.toString());
        }

        List<MavenGav> gavs = new ArrayList<>();
        for (String dep : deps) {
            MavenGav gav = parseMavenGav(dep);
            String gid = gav.getGroupId();
            String aid = gav.getArtifactId();

             
            if ("org.apache.camel".equals(gid)) {
                ArtifactModel<?> am = catalog.modelFromMavenGAV("org.apache.camel.springboot", aid + "-starter", null);
                if (am != null) {
                     
                    gav.setGroupId(am.getGroupId());
                    gav.setArtifactId(am.getArtifactId());
                    gav.setVersion(am.getVersion());
                } else {
                     
                    gav.setVersion(camelVersion);
                }
            }
            gavs.add(gav);
        }

         
        gavs.sort(mavenGavComparator());

        StringBuilder sb = new StringBuilder();
        for (MavenGav gav : gavs) {
            if ("lib".equals(gav.getPackaging())) {
                 
                sb.append("    implementation files('lib/").append(gav.getArtifactId())
                        .append("-").append(gav.getVersion()).append(".jar')\n");
            } else if ("camel-kamelets-utils".equals(gav.getArtifactId())) {
                 
                sb.append("    implementation ('").append(gav).append("') {\n");
                sb.append("        exclude group: 'org.apache.camel', module: '*'\n");
                sb.append("    }\n");
            } else {
                sb.append("    implementation '").append(gav).append("'\n");
            }
        }
        context = context.replaceFirst("\\{\\{ \\.CamelDependencies }}", sb.toString());

        IOHelper.writeText(context, Files.newOutputStream(gradleBuild));
    }

    protected Set<FieldInfo> fields(ClassInfo ci) {
        Set<FieldInfo> fields = new TreeSet<>(Comparator.comparing(FieldInfo::name));

        ClassInfo current = ci;
        while (current != null) {
            fields.addAll(current.fields());

            DotName superName = current.superName();
            if (superName == null) {
                break;
            }

            current = view.getClassByName(superName);
        }

        return fields;
    }

    private static String doLoad(File file, String kind) {
        try {
            String json = PackageHelper.loadText(file);
            if (Objects.equals(kind, PackageHelper.getSchemaKind(json))) {
                return json;
            }
        } catch (IOException ignored) {
             
        }
        return null;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        boolean cache = getAndRemoveParameter(parameters, "contentCache", Boolean.class, contentCache);

        VelocityEndpoint answer = new VelocityEndpoint(uri, this, remaining);
        answer.setContentCache(cache);
        answer.setVelocityEngine(velocityEngine);
        answer.setAllowTemplateFromHeader(allowTemplateFromHeader);
        answer.setAllowContextMapAll(allowContextMapAll);

        setProperties(answer, parameters);

         
        if (ResourceHelper.isHttpUri(remaining)) {
            remaining = ResourceHelper.appendParameters(remaining, parameters);
            answer.setResourceUri(remaining);
        }

        return answer;
    }

    protected void populateRequestParameters(HttpServletRequest request, Message message) {
        super.populateRequestParameters(request, message);

        String path = request.getPathInfo();
        if (path == null) {
            return;
        }

         
         

        JettyHttpEndpoint endpoint = (JettyHttpEndpoint) message.getExchange().getFromEndpoint();
        String consumerPath = endpoint.getPath();

        if (useRestMatching(consumerPath)) {
            evalPlaceholders(message.getHeaders(), path, consumerPath);
        }
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((DebeziumDb2Component) component).setAdditionalProperties((java.util.Map) value); return true;
            case "bridgeErrorHandler": ((DebeziumDb2Component) component).setBridgeErrorHandler((boolean) value); return true;
            case "configuration": ((DebeziumDb2Component) component).setConfiguration((org.apache.camel.component.debezium.db2.configuration.Db2ConnectorEmbeddedDebeziumConfiguration) value); return true;
            case "internalKeyConverter": getOrCreateConfiguration((DebeziumDb2Component) component).setInternalKeyConverter((java.lang.String) value); return true;
            case "internalValueConverter": getOrCreateConfiguration((DebeziumDb2Component) component).setInternalValueConverter((java.lang.String) value); return true;
            case "offsetCommitPolicy": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetCommitPolicy((java.lang.String) value); return true;
            case "offsetCommitTimeoutMs": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetCommitTimeoutMs((long) value); return true;
            case "offsetFlushIntervalMs": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetFlushIntervalMs((long) value); return true;
            case "offsetStorage": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetStorage((java.lang.String) value); return true;
            case "offsetStorageFileName": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetStorageFileName((java.lang.String) value); return true;
            case "offsetStoragePartitions": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetStoragePartitions((int) value); return true;
            case "offsetStorageReplicationFactor": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetStorageReplicationFactor((int) value); return true;
            case "offsetStorageTopic": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetStorageTopic((java.lang.String) value); return true;
            case "autowiredEnabled": ((DebeziumDb2Component) component).setAutowiredEnabled((boolean) value); return true;
            case "cdcChangeTablesSchema": getOrCreateConfiguration((DebeziumDb2Component) component).setCdcChangeTablesSchema((java.lang.String) value); return true;
            case "cdcControlSchema": getOrCreateConfiguration((DebeziumDb2Component) component).setCdcControlSchema((java.lang.String) value); return true;
            case "columnExcludeList": getOrCreateConfiguration((DebeziumDb2Component) component).setColumnExcludeList((java.lang.String) value); return true;
            case "columnIncludeList": getOrCreateConfiguration((DebeziumDb2Component) component).setColumnIncludeList((java.lang.String) value); return true;
            case "columnPropagateSourceType": getOrCreateConfiguration((DebeziumDb2Component) component).setColumnPropagateSourceType((java.lang.String) value); return true;
            case "connectionValidationTimeoutMs": getOrCreateConfiguration((DebeziumDb2Component) component).setConnectionValidationTimeoutMs((long) value); return true;
            case "converters": getOrCreateConfiguration((DebeziumDb2Component) component).setConverters((java.lang.String) value); return true;
            case "customMetricTags": getOrCreateConfiguration((DebeziumDb2Component) component).setCustomMetricTags((java.lang.String) value); return true;
            case "customSanitizePattern": getOrCreateConfiguration((DebeziumDb2Component) component).setCustomSanitizePattern((java.lang.String) value); return true;
            case "databaseDbname": getOrCreateConfiguration((DebeziumDb2Component) component).setDatabaseDbname((java.lang.String) value); return true;
            case "databaseHostname": getOrCreateConfiguration((DebeziumDb2Component) component).setDatabaseHostname((java.lang.String) value); return true;
            case "databasePassword": getOrCreateConfiguration((DebeziumDb2Component) component).setDatabasePassword((java.lang.String) value); return true;
            case "databasePort": getOrCreateConfiguration((DebeziumDb2Component) component).setDatabasePort((int) value); return true;
            case "databaseUser": getOrCreateConfiguration((DebeziumDb2Component) component).setDatabaseUser((java.lang.String) value); return true;
            case "datatypePropagateSourceType": getOrCreateConfiguration((DebeziumDb2Component) component).setDatatypePropagateSourceType((java.lang.String) value); return true;
            case "db2Platform": getOrCreateConfiguration((DebeziumDb2Component) component).setDb2Platform((java.lang.String) value); return true;
            case "decimalHandlingMode": getOrCreateConfiguration((DebeziumDb2Component) component).setDecimalHandlingMode((java.lang.String) value); return true;
            case "errorsMaxRetries": getOrCreateConfiguration((DebeziumDb2Component) component).setErrorsMaxRetries((int) value); return true;
            case "eventProcessingFailureHandlingMode": getOrCreateConfiguration((DebeziumDb2Component) component).setEventProcessingFailureHandlingMode((java.lang.String) value); return true;
            case "executorShutdownTimeoutMs": getOrCreateConfiguration((DebeziumDb2Component) component).setExecutorShutdownTimeoutMs((long) value); return true;
            case "extendedHeadersEnabled": getOrCreateConfiguration((DebeziumDb2Component) component).setExtendedHeadersEnabled((boolean) value); return true;
            case "guardrailCollectionsLimitAction": getOrCreateConfiguration((DebeziumDb2Component) component).setGuardrailCollectionsLimitAction((java.lang.String) value); return true;
            case "guardrailCollectionsMax": getOrCreateConfiguration((DebeziumDb2Component) component).setGuardrailCollectionsMax((int) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((DebeziumDb2Component) component).setHeartbeatIntervalMs((int) value); return true;
            case "heartbeatTopicsPrefix": getOrCreateConfiguration((DebeziumDb2Component) component).setHeartbeatTopicsPrefix((java.lang.String) value); return true;
            case "includeSchemaChanges": getOrCreateConfiguration((DebeziumDb2Component) component).setIncludeSchemaChanges((boolean) value); return true;
            case "incrementalSnapshotChunkSize": getOrCreateConfiguration((DebeziumDb2Component) component).setIncrementalSnapshotChunkSize((int) value); return true;
            case "incrementalSnapshotWatermarkingStrategy": getOrCreateConfiguration((DebeziumDb2Component) component).setIncrementalSnapshotWatermarkingStrategy((java.lang.String) value); return true;
            case "maxBatchSize": getOrCreateConfiguration((DebeziumDb2Component) component).setMaxBatchSize((int) value); return true;
            case "maxQueueSize": getOrCreateConfiguration((DebeziumDb2Component) component).setMaxQueueSize((int) value); return true;
            case "maxQueueSizeInBytes": getOrCreateConfiguration((DebeziumDb2Component) component).setMaxQueueSizeInBytes((long) value); return true;
            case "messageKeyColumns": getOrCreateConfiguration((DebeziumDb2Component) component).setMessageKeyColumns((java.lang.String) value); return true;
            case "notificationEnabledChannels": getOrCreateConfiguration((DebeziumDb2Component) component).setNotificationEnabledChannels((java.lang.String) value); return true;
            case "notificationSinkTopicName": getOrCreateConfiguration((DebeziumDb2Component) component).setNotificationSinkTopicName((java.lang.String) value); return true;
            case "openlineageIntegrationConfigFilePath": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationConfigFilePath((java.lang.String) value); return true;
            case "openlineageIntegrationDatasetKafkaBootstrapServers": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationDatasetKafkaBootstrapServers((java.lang.String) value); return true;
            case "openlineageIntegrationEnabled": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationEnabled((boolean) value); return true;
            case "openlineageIntegrationJobDescription": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationJobDescription((java.lang.String) value); return true;
            case "openlineageIntegrationJobNamespace": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationJobNamespace((java.lang.String) value); return true;
            case "openlineageIntegrationJobOwners": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationJobOwners((java.lang.String) value); return true;
            case "openlineageIntegrationJobTags": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationJobTags((java.lang.String) value); return true;
            case "pollIntervalMs": getOrCreateConfiguration((DebeziumDb2Component) component).setPollIntervalMs((long) value); return true;
            case "postProcessors": getOrCreateConfiguration((DebeziumDb2Component) component).setPostProcessors((java.lang.String) value); return true;
            case "provideTransactionMetadata": getOrCreateConfiguration((DebeziumDb2Component) component).setProvideTransactionMetadata((boolean) value); return true;
            case "queryFetchSize": getOrCreateConfiguration((DebeziumDb2Component) component).setQueryFetchSize((int) value); return true;
            case "retriableRestartConnectorWaitMs": getOrCreateConfiguration((DebeziumDb2Component) component).setRetriableRestartConnectorWaitMs((long) value); return true;
            case "schemaHistoryInternal": getOrCreateConfiguration((DebeziumDb2Component) component).setSchemaHistoryInternal((java.lang.String) value); return true;
            case "schemaHistoryInternalFileFilename": getOrCreateConfiguration((DebeziumDb2Component) component).setSchemaHistoryInternalFileFilename((java.lang.String) value); return true;
            case "schemaHistoryInternalSkipUnparseableDdl": getOrCreateConfiguration((DebeziumDb2Component) component).setSchemaHistoryInternalSkipUnparseableDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedDatabasesDdl": getOrCreateConfiguration((DebeziumDb2Component) component).setSchemaHistoryInternalStoreOnlyCapturedDatabasesDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedTablesDdl": getOrCreateConfiguration((DebeziumDb2Component) component).setSchemaHistoryInternalStoreOnlyCapturedTablesDdl((boolean) value); return true;
            case "schemaNameAdjustmentMode": getOrCreateConfiguration((DebeziumDb2Component) component).setSchemaNameAdjustmentMode((java.lang.String) value); return true;
            case "signalDataCollection": getOrCreateConfiguration((DebeziumDb2Component) component).setSignalDataCollection((java.lang.String) value); return true;
            case "signalEnabledChannels": getOrCreateConfiguration((DebeziumDb2Component) component).setSignalEnabledChannels((java.lang.String) value); return true;
            case "signalPollIntervalMs": getOrCreateConfiguration((DebeziumDb2Component) component).setSignalPollIntervalMs((long) value); return true;
            case "skippedOperations": getOrCreateConfiguration((DebeziumDb2Component) component).setSkippedOperations((java.lang.String) value); return true;
            case "snapshotDelayMs": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotDelayMs((long) value); return true;
            case "snapshotFetchSize": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotFetchSize((int) value); return true;
            case "snapshotIncludeCollectionList": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotIncludeCollectionList((java.lang.String) value); return true;
            case "snapshotLockTimeoutMs": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotLockTimeoutMs((long) value); return true;
            case "snapshotMode": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotMode((java.lang.String) value); return true;
            case "snapshotModeConfigurationBasedSnapshotData": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotModeConfigurationBasedSnapshotData((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnDataError": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotModeConfigurationBasedSnapshotOnDataError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnSchemaError": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotModeConfigurationBasedSnapshotOnSchemaError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotSchema": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotModeConfigurationBasedSnapshotSchema((boolean) value); return true;
            case "snapshotModeConfigurationBasedStartStream": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotModeConfigurationBasedStartStream((boolean) value); return true;
            case "snapshotModeCustomName": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotModeCustomName((java.lang.String) value); return true;
            case "snapshotSelectStatementOverrides": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotSelectStatementOverrides((java.lang.String) value); return true;
            case "snapshotTablesOrderByRowCount": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotTablesOrderByRowCount((java.lang.String) value); return true;
            case "sourceinfoStructMaker": getOrCreateConfiguration((DebeziumDb2Component) component).setSourceinfoStructMaker((java.lang.String) value); return true;
            case "streamingDelayMs": getOrCreateConfiguration((DebeziumDb2Component) component).setStreamingDelayMs((long) value); return true;
            case "tableExcludeList": getOrCreateConfiguration((DebeziumDb2Component) component).setTableExcludeList((java.lang.String) value); return true;
            case "tableIgnoreBuiltin": getOrCreateConfiguration((DebeziumDb2Component) component).setTableIgnoreBuiltin((boolean) value); return true;
            case "tableIncludeList": getOrCreateConfiguration((DebeziumDb2Component) component).setTableIncludeList((java.lang.String) value); return true;
            case "timePrecisionMode": getOrCreateConfiguration((DebeziumDb2Component) component).setTimePrecisionMode((java.lang.String) value); return true;
            case "tombstonesOnDelete": getOrCreateConfiguration((DebeziumDb2Component) component).setTombstonesOnDelete((boolean) value); return true;
            case "topicNamingStrategy": getOrCreateConfiguration((DebeziumDb2Component) component).setTopicNamingStrategy((java.lang.String) value); return true;
            case "topicPrefix": getOrCreateConfiguration((DebeziumDb2Component) component).setTopicPrefix((java.lang.String) value); return true;
            case "transactionMetadataFactory": getOrCreateConfiguration((DebeziumDb2Component) component).setTransactionMetadataFactory((java.lang.String) value); return true;
            default: return false;
            }
        }

    private Queue<Exchange> createBatchExchangesFromContainer(final BlobContainerClient blobContainerClient)
            throws IOException {
        final BlobContainerClientWrapper containerClientWrapper = new BlobContainerClientWrapper(blobContainerClient);
        final BlobContainerOperations containerOperations
                = new BlobContainerOperations(getEndpoint().getConfiguration(), containerClientWrapper);

        final List<BlobItem> blobs = (List<BlobItem>) containerOperations.listBlobs(null).getBody();

         
        forceConsumerAsReady();

        final Queue<Exchange> exchanges = new LinkedList<>();
        for (BlobItem blobItem : blobs) {
            exchanges.add(createExchangeFromBlob(blobItem.getName(), blobContainerClient));
        }
        return exchanges;
    }

    public Calendar getClient(GoogleCalendarConfiguration config) {
        if (client == null) {
            if (config.getClientId() != null && !config.getClientId().isBlank()
                    && config.getClientSecret() != null && !config.getClientSecret().isBlank()) {
                client = getClientFactory().makeClient(config.getClientId(), config.getClientSecret(), config.getScopesAsList(),
                        config.getApplicationName(), config.getRefreshToken(),
                        config.getAccessToken(), config.getEmailAddress(), config.getP12FileName(), config.getUser());
            } else if (config.getServiceAccountKey() != null && !config.getServiceAccountKey().isBlank()) {
                client = getClientFactory().makeClient(getCamelContext(), config.getServiceAccountKey(),
                        config.getScopesAsList(),
                        config.getApplicationName(), config.getDelegate());
            } else {
                throw new IllegalArgumentException(
                        "(clientId and clientSecret) or serviceAccountKey are required to create Google Calendar client");
            }
        }
        return client;
    }

    private static GenericFileExclusiveReadLockStrategy getExclusiveReadLockStrategy(Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy strategy
                = (GenericFileExclusiveReadLockStrategy) params.get("exclusiveReadLockStrategy");
        if (strategy != null) {
            return strategy;
        }

         
        String readLock = (String) params.get("readLock");
        if (ObjectHelper.isNotEmpty(readLock)) {
            if ("none".equals(readLock) || "false".equals(readLock)) {
                return null;
            } else if ("rename".equals(readLock)) {
                GenericFileRenameExclusiveReadLockStrategy<SftpRemoteFile> readLockStrategy
                        = new GenericFileRenameExclusiveReadLockStrategy<>();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            } else if ("changed".equals(readLock)) {
                SftpChangedExclusiveReadLockStrategy readLockStrategy = new SftpChangedExclusiveReadLockStrategy();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            }
        }

        return null;
    }

    public String browseMessageBody(Integer index) {
        List<Exchange> exchanges = getEndpoint().getExchanges();

        if (index >= exchanges.size()) {
            return null;
        }
        Exchange exchange = exchanges.get(index);
        if (exchange == null) {
            return null;
        }

        Message msg = exchange.getMessage();
        return MessageHelper.extractBodyAsString(msg);
    }

    public GenericFileProcessStrategy<FileIdBothDirectoryInformation> createGenericFileProcessStrategy(
            CamelContext context, Map<String, Object> params) {

         
         
        Expression moveExpression = (Expression) params.get("move");
        Expression moveFailedExpression = (Expression) params.get("moveFailed");
        Expression preMoveExpression = (Expression) params.get("preMove");
        boolean isNoop = params.get("noop") != null;
        boolean isDelete = params.get("delete") != null;
        boolean isMove = moveExpression != null || preMoveExpression != null || moveFailedExpression != null;

        if (isDelete) {
            GenericFileDeleteProcessStrategy<FileIdBothDirectoryInformation> strategy
                    = new GenericFileDeleteProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
            return strategy;
        } else if (isMove || isNoop) {
            GenericFileRenameProcessStrategy<FileIdBothDirectoryInformation> strategy
                    = new GenericFileRenameProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (!isNoop && moveExpression != null) {
                 
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveExpression);
                strategy.setCommitRenamer(renamer);
            }
             
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
             
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<FileIdBothDirectoryInformation> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            return strategy;
        } else {
             
            GenericFileNoOpProcessStrategy<FileIdBothDirectoryInformation> strategy = new GenericFileNoOpProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            return strategy;
        }
    }

    public void removeConsumer(String key, DirectConsumer consumer) {
        consumersLock.lock();
        try {
            consumers.remove(key, consumer);
             
            stateCounter++;
            consumersCondition.signalAll();
        } finally {
            consumersLock.unlock();
        }
    }

    public boolean acquireExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
            throws Exception {
         
         
        File path = file.getFile();
        if (!path.exists()) {
            return false;
        }

         
        String key = asKey(exchange, file);
        boolean answer = false;
        try {
            answer = idempotentRepository.add(exchange, key);
        } catch (Exception e) {
            if (LOG.isTraceEnabled()) {
                LOG.trace("Cannot acquire read lock due to {}. Will skip the file: {}", e.getMessage(), file, e);
            }
        }
        if (!answer) {
             
            CamelLogger.log(LOG, readLockLoggingLevel, "Cannot acquire read lock. Will skip the file: " + file);
        }

        if (answer) {
             
            answer = rename.acquireExclusiveReadLock(operations, file, exchange);
            if (!answer) {
                 
                idempotentRepository.remove(exchange, key);
            }
        }
        return answer;
    }

    public GoogleMailConfiguration getEndpointConfiguration(GoogleMailApiName apiName) {
        GoogleMailConfiguration result = null;
        switch (apiName) {
            case THREADS:
                result = new GmailUsersThreadsEndpointConfiguration();
                break;
            case MESSAGES:
                result = new GmailUsersMessagesEndpointConfiguration();
                break;
            case ATTACHMENTS:
                result = new GmailUsersMessagesAttachmentsEndpointConfiguration();
                break;
            case LABELS:
                result = new GmailUsersLabelsEndpointConfiguration();
                break;
            case HISTORY:
                result = new GmailUsersHistoryEndpointConfiguration();
                break;
            case DRAFTS:
                result = new GmailUsersDraftsEndpointConfiguration();
                break;
            case USERS:
                result = new GmailUsersEndpointConfiguration();
                break;
        }
        return result;
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            LoopState state = new LoopState(exchange, callback);

            if (exchange.isTransacted()) {
                reactiveExecutor.scheduleQueue(state);
            } else {
                reactiveExecutor.scheduleMain(state);
            }
            return false;
        } catch (Exception e) {
            exchange.setException(e);
            callback.done(true);
            return true;
        }
    }

    private void createZipEntries(ZipArchiveOutputStream zos, String filepath, Long fileLength) throws IOException {
        Iterator<Path> elements = Paths.get(filepath).iterator();
        StringBuilder sb = new StringBuilder(256);

        while (elements.hasNext()) {
            Path path = elements.next();
            String element = path.toString();
            Long length = fileLength;

             
             
            if (elements.hasNext()) {
                element += "/";
                length = 0L;
            }

             
            ZipArchiveEntry entry = new ZipArchiveEntry(sb + element);
            entry.setSize(length);
            zos.putArchiveEntry(entry);

            sb.append(element);
        }
    }

    public RestDefinition enableCORS(boolean enableCORS) {
        if (getVerbs().isEmpty()) {
            this.enableCORS = Boolean.toString(enableCORS);
        } else {
             
            VerbDefinition verb = getVerbs().get(getVerbs().size() - 1);
            verb.setEnableCORS(Boolean.toString(enableCORS));
        }

        return this;
    }

    public void reset(boolean includeRoutes) throws Exception {
        reset();
        load.reset();
        thp.reset();

         
        if (includeRoutes) {
            MBeanServer server = getContext().getManagementStrategy().getManagementAgent().getMBeanServer();
            if (server != null) {
                String prefix = getContext().getManagementStrategy().getManagementAgent().getIncludeHostName() ? "*/" : "";
                ObjectName query = ObjectName
                        .getInstance(jmxDomain + ":context=" + prefix + getContext().getManagementName() + ",type=routes,*");
                Set<ObjectName> names = server.queryNames(query, null);
                for (ObjectName name : names) {
                    server.invoke(name, "reset", new Object[] { true }, new String[] { "boolean" });
                }
            }
        }
    }

    public void changeQueryJobState(
            String jobId, JobStateEnum state, Map<String, List<String>> headers, QueryJobResponseCallback callback) {
        final Request request = getRequest(HttpMethod.PATCH, queryJobUrl(jobId), headers);
        QueryJob job = new QueryJob();
        job.setId(jobId);
        job.setState(state);
        try {
            marshalRequest(job, request);
        } catch (SalesforceException e) {
            callback.onResponse(null, Collections.emptyMap(), e);
            return;
        }
        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                if (ex != null) {
                    callback.onResponse(null, headers, ex);
                }
                QueryJob responseJob = null;
                try {
                    responseJob = unmarshalResponse(response, request, QueryJob.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(responseJob, headers, ex);
            }
        });
    }

    public static Expression fileParentExpression() {
        return new ExpressionAdapter() {
            @Override
            public Object evaluate(Exchange exchange) {
                return exchange.getIn().getHeader("CamelFileParent", String.class);
            }

            @Override
            public String toString() {
                return "file:parent";
            }
        };
    }

    public int processBatch(Queue<Object> exchanges) throws Exception {
        int total = exchanges.size();

        for (int index = 0; index < total && isBatchAllowed(); index++) {
             
            final Exchange exchange = ObjectHelper.cast(Exchange.class, exchanges.poll());
             
            exchange.setProperty(ExchangePropertyKey.BATCH_INDEX, index);
            exchange.setProperty(ExchangePropertyKey.BATCH_SIZE, total);
            exchange.setProperty(ExchangePropertyKey.BATCH_COMPLETE, index == total - 1);

             
            pendingExchanges = total - index - 1;

             
             
            if (!getEndpoint().getConfiguration().isBatchDelete()) {
                exchange.getExchangeExtension().addOnCompletion(new Synchronization() {
                    final String reservationId
                            = ExchangeHelper.getMandatoryHeader(exchange, IronMQConstants.MESSAGE_RESERVATION_ID, String.class);
                    final String messageid
                            = ExchangeHelper.getMandatoryHeader(exchange, IronMQConstants.MESSAGE_ID, String.class);

                    public void onComplete(Exchange exchange) {
                        processCommit(exchange, messageid, reservationId);
                    }

                    public void onFailure(Exchange exchange) {
                        processRollback(exchange);
                    }

                    @Override
                    public String toString() {
                        return "IronMQConsumerOnCompletion";
                    }
                });
            }

            LOG.trace("Processing exchange [{}]...", exchange);

            getProcessor().process(exchange);
        }

        return total;
    }

    public CompletableFuture<Void> compensate(URL lra, Exchange exchange) {
        HttpRequest request = prepareRequest(URI.create(lra.toString() + COORDINATOR_PATH_CANCEL), exchange)
                .setHeader(CONTENT_TYPE, TEXT_PLAIN_CONTENT)
                .PUT(HttpRequest.BodyPublishers.ofString(""))
                .build();

        CompletableFuture<HttpResponse<String>> future = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        return future.thenApply(response -> {
            if (response.statusCode() != HttpURLConnection.HTTP_OK) {
                throw new RuntimeCamelException("Cannot compensate LRA");
            }

            return null;
        });
    }

    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("KeyManagersParameters[keyStore=");
        builder.append(keyStore);
        builder.append(", keyPassword=");
        builder.append("********");
        builder.append(", provider=");
        builder.append(provider);
        builder.append(", algorithm=");
        builder.append(algorithm);
        builder.append("]");
        return builder.toString();
    }

    protected void postProcessFactoryParameters(CamelContext camelContext, Map<String, Object> parameters) throws Exception {
        List<String> servers = List.class.cast(parameters.get("servers"));

        if (ObjectHelper.isNotEmpty(servers)) {
            final ListIterator<String> it = servers.listIterator();
            while (it.hasNext()) {
                it.set(camelContext.resolvePropertyPlaceholders(it.next()));
            }

            parameters.put("servers", servers);
        }
    }

        public String toString() {
            if (!onCompleteOnly && !onFailureOnly) {
                return "onCompleteOrFailure";
            } else if (onCompleteOnly) {
                return "onCompleteOnly";
            } else {
                return "onFailureOnly";
            }
        }

    public void execute() throws MojoExecutionException {
        File camelDir = findCamelDirectory(baseDir, "core/camel-util");
        if (camelDir == null) {
            getLog().debug("No core/camel-util folder found, skipping execution");
            return;
        }
        List<Path> jsonFiles;
        try (Stream<Path> stream = PackageHelper.findJsonFiles(jsonDir.toPath())) {
            jsonFiles = stream.toList();
        }
        Set<String> importants = new TreeSet<>();

        for (Path file : jsonFiles) {
            final String name = PackageHelper.asName(file);

            try {
                String json = PackageHelper.loadText(file.toFile());
                Object jo = Jsoner.deserialize(json);
                JsonObject obj;
                if (jo instanceof JsonObject) {
                    obj = (JsonObject) jo;
                } else {
                    continue;
                }

                boolean isComponent = obj.getMap("component") != null;
                boolean isEip = !isComponent && obj.getMap("model") != null;

                 
                if (!isComponent && !isEip) {
                    continue;
                }

                if (isComponent) {
                    ComponentModel cm = JsonMapper.generateComponentModel(json);
                    cm.getEndpointHeaders().forEach(o -> {
                        if (o.isImportant()) {
                            importants.add(o.getName());
                        }
                    });
                } else if (isEip) {
                    EipModel em = JsonMapper.generateEipModel(json);
                    em.getExchangeProperties().forEach(o -> {
                        if (o.isImportant()) {
                            importants.add(o.getName());
                        }
                    });
                }
            } catch (Exception e) {
                throw new MojoExecutionException("Error loading json: " + name, e);
            }
        }

        getLog().info("There are " + importants.size()
                      + " distinct important options across all the Camel components/eips");

        try {
            boolean updated = updateImportantHeaderKeys(camelDir, importants);
            if (updated) {
                getLog().info("Updated camel-util/src/main/java/org/apache/camel/util/ImportantHeaderUtils.java file");
            } else {
                getLog().debug("No changes to camel-util/src/main/java/org/apache/camel/util/ImportantHeaderUtils.java file");
            }
        } catch (Exception e) {
            throw new MojoExecutionException("Error updating ImportantHeaderUtils.java", e);
        }

        try {
            updateImportantHeaderJsonSchema(baseDir, importants);
        } catch (Exception e) {
            throw new MojoExecutionException("Error updating important-headers.json", e);
        }
    }

    public static AS2MessageDispositionNotificationEntity parseMessageDispositionNotificationEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            String charsetName)
            throws ParseException {
        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {

            if (charsetName == null) {
                charsetName = StandardCharsets.US_ASCII.name();
            }
            Charset charset = Charset.forName(charsetName);
            CharsetDecoder charsetDecoder = charset.newDecoder();

            inbuffer.setCharsetDecoder(charsetDecoder);

            List<CharArrayBuffer> dispositionNotificationFields = parseBodyPartFields(inbuffer, is, boundary,
                    BasicLineParser.INSTANCE, new ArrayList<>());

            AS2MessageDispositionNotificationEntity as2MessageDispositionNotificationEntity
                    = DispositionNotificationContentUtils.parseDispositionNotification(dispositionNotificationFields);
            return as2MessageDispositionNotificationEntity;
        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse MDN entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }
    }

    public static Point fromMapToPoint(Map<String, Object> map) {
        Object measurementName = map.get(InfluxDbConstants.MEASUREMENT_NAME);
        if (measurementName == null) {
            String format = String.format("Unable to find the header for the measurement in: %s", map.keySet().toString());
            throw new CamelInfluxDbException(format);
        }

        String measurenmentNameString = measurementName.toString();
        Point.Builder pointBuilder = Point.measurement(measurenmentNameString);
        map.remove(InfluxDbConstants.MEASUREMENT_NAME);
        pointBuilder.fields(map);
        map.put(InfluxDbConstants.MEASUREMENT_NAME, measurementName);
        return pointBuilder.build();
    }

  protected static final String addEscapes(String str) {
    StringBuilder retval = new StringBuilder();
    char ch;
    for (int i = 0; i < str.length(); i++) {
      switch (str.charAt(i))
      {
        case '\b':
          retval.append("\\b");
          continue;
        case '\t':
          retval.append("\\t");
          continue;
        case '\n':
          retval.append("\\n");
          continue;
        case '\f':
          retval.append("\\f");
          continue;
        case '\r':
          retval.append("\\r");
          continue;
        case '\"':
          retval.append("\\\"");
          continue;
        case '\'':
          retval.append("\\\'");
          continue;
        case '\\':
          retval.append("\\\\");
          continue;
        default:
          if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
            String s = "0000" + Integer.toString(ch, 16);
            retval.append("\\u" + s.substring(s.length() - 4, s.length()));
          } else {
            retval.append(ch);
          }
          continue;
      }
    }
    return retval.toString();
  }

    public static void skipPreambleAndStartBoundary(AS2SessionInputBuffer inbuffer, InputStream is, String boundary)
            throws HttpException {

        boolean foundStartBoundary;
        try {
            foundStartBoundary = false;
            CharArrayBuffer lineBuffer = new CharArrayBuffer(1024);
            while (inbuffer.readLine(lineBuffer, is) != -1) {
                final ParserCursor cursor = new ParserCursor(0, lineBuffer.length());
                if (isBoundaryDelimiter(lineBuffer, cursor, boundary)) {
                    foundStartBoundary = true;
                    break;
                }
                lineBuffer.clear();
            }
        } catch (Exception e) {
            throw new HttpException("Failed to read start boundary for body part", e);
        }

        if (!foundStartBoundary) {
            throw new HttpException("Failed to find start boundary for body part");
        }

    }

    public GetCommitFileProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_DATA_SERVICE);
        if (service != null) {
            LOG.debug("Using DataService found in registry {}", service.getClass().getCanonicalName());
            dataService = (DataService) service;
        } else {
            dataService = new DataService();
        }
        initService(dataService);

        if (endpoint.getEncoding() != null) {
            encoding = endpoint.getEncoding();

            if (!encoding.equalsIgnoreCase(Blob.ENCODING_BASE64)
                    && !encoding.equalsIgnoreCase(Blob.ENCODING_UTF8)) {
                throw new IllegalArgumentException("Unknown encoding '" + encoding + "'");
            }
        }
    }

    public Processor wrap(Route route, Processor processor) {
        JtaTransactionErrorHandler answer;
         
         
         
         
         
         
         
         

         
        RouteDefinition routeDefinition = (RouteDefinition) route.getRoute();
        ErrorHandlerFactory builder = routeDefinition.getErrorHandlerFactory();

         
        if (builder instanceof RefErrorHandlerDefinition) {
             
            RefErrorHandlerDefinition builderRef = (RefErrorHandlerDefinition) builder;
            String ref = builderRef.getRef();
             
             
             
            if (ErrorHandlerHelper.isErrorHandlerFactoryConfigured(ref)) {
                LOG.debug("Looking up ErrorHandlerBuilder with ref: {}", ref);
                builder = ErrorHandlerHelper.lookupErrorHandlerFactory(route, ref, true);
            }
        }

        JtaTransactionErrorHandlerDefinition txBuilder;
        if (builder != null && builder.supportTransacted()) {
            if (!(builder instanceof JtaTransactionErrorHandlerDefinition)) {
                throw new RuntimeCamelException(
                        "The given transactional error handler builder '" + builder
                                                + "' is not of type '" + JtaTransactionErrorHandlerDefinition.class.getName()
                                                + "' which is required in this environment!");
            }
            LOG.debug("The ErrorHandlerBuilder configured is a JtaTransactionErrorHandlerDefinition: {}", builder);
            txBuilder = (JtaTransactionErrorHandlerDefinition) builder.cloneBuilder();
        } else {
            LOG.debug(
                    "No or no transactional ErrorHandlerBuilder configured, will use default JtaTransactionErrorHandlerDefinition settings");
            txBuilder = new JtaTransactionErrorHandlerDefinition();
        }

        txBuilder.setTransactedPolicy(this);

         
        if (builder != null) {
            route.addErrorHandlerFactoryReference(builder, txBuilder);
        }

        answer = createTransactionErrorHandler(route, processor, txBuilder);

         
        route.setErrorHandlerFactory(txBuilder);

         
        return answer;
    }

    public OutputLengthGuardrail(int maxChars, int minChars, boolean truncateOnOverflow) {
        if (maxChars <= 0) {
            throw new IllegalArgumentException("maxChars must be positive");
        }
        if (minChars < 0) {
            throw new IllegalArgumentException("minChars cannot be negative");
        }
        if (minChars > maxChars) {
            throw new IllegalArgumentException("minChars cannot exceed maxChars");
        }
        this.maxChars = maxChars;
        this.minChars = minChars;
        this.truncateOnOverflow = truncateOnOverflow;
    }

    private void closeQuietly(ResultSet rs) {
        if (rs != null) {
            try {
                if (!rs.isClosed()) {
                    rs.close();
                }
            } catch (Exception sqle) {
                LOG.debug("Error by closing result set", sqle);
            }
        }
    }

    public Map<String, Object> endpointLenientProperties(Exchange exchange, String uri) throws Exception {
        Map<String, Object> properties;
         
        Map<String, Object> map = URISupport.parseQuery(URISupport.extractQuery(uri));
        if (map != null && !map.isEmpty()) {
            if (resolveRawParameterValues()) {
                 
                 
                 
                RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map);
            }
            properties = new LinkedHashMap<>();
            map.forEach((k, v) -> {
                 
                 
                boolean accept = !knownProperties.contains(k);
                if (accept && !knownPrefixes.isEmpty()) {
                    accept = knownPrefixes.values().stream().noneMatch(k::startsWith);
                }
                if (accept) {
                    properties.put(k, v.toString());
                }
            });
        } else {
            properties = map;
        }
        return properties;
    }

    protected void doDeleteNode(Exchange exchange) {
        String nodeName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NODE_NAME, String.class);
        if (ObjectHelper.isEmpty(nodeName)) {
            LOG.error("Deleting a specific Node require specify a Node name");
            throw new IllegalArgumentException("Deleting a specific Node require specify a Node name");
        }

        List<StatusDetails> statusDetails = getEndpoint().getKubernetesClient().nodes().withName(nodeName).delete();
        boolean nodeDeleted = ObjectHelper.isNotEmpty(statusDetails);

        prepareOutboundMessage(exchange, nodeDeleted);
    }

    protected String createEndpointUri() {
        if (channelKey != null) {
            return "flowable:" + channelKey;
        } else if (camelInboundChannel != null) {
            return "flowable:" + camelInboundChannel.getKey();
        } else {
            return "flowable:" + camelOutboundChannel.getKey();
        }
    }

    public static AS2MessageDispositionNotificationEntity parseMessageDispositionNotificationEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            String charsetName)
            throws ParseException {
        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {

            if (charsetName == null) {
                charsetName = StandardCharsets.US_ASCII.name();
            }
            Charset charset = Charset.forName(charsetName);
            CharsetDecoder charsetDecoder = charset.newDecoder();

            inbuffer.setCharsetDecoder(charsetDecoder);

            List<CharArrayBuffer> dispositionNotificationFields = parseBodyPartFields(inbuffer, is, boundary,
                    BasicLineParser.INSTANCE, new ArrayList<>());

            AS2MessageDispositionNotificationEntity as2MessageDispositionNotificationEntity
                    = DispositionNotificationContentUtils.parseDispositionNotification(dispositionNotificationFields);
            return as2MessageDispositionNotificationEntity;
        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse MDN entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }
    }

    protected boolean matchSecret(String name) {
        Set<String> set = new HashSet<>();
        if (secrets != null) {
            Collections.addAll(set, secrets.split(","));
        }
        if (propertiesFunction != null) {
            set.addAll(propertiesFunction.getSecrets());
        }

        for (String part : set) {
            boolean result = name.contains(part) || PatternHelper.matchPattern(name, part);
            LOG.trace("Matching secret id: {}={} -> {}", name, part, result);
            if (result) {
                return true;
            }
        }

        return false;
    }

    public List<Exchange> getExchanges(int limit, Predicate filter) {
        if (queueBrowseStrategy == null) {
            return Collections.emptyList();
        }
        String queue = getDestinationName();
        JmsOperations template = getConfiguration().createInOnlyTemplate(this, false, queue);
        List<Exchange> list = queueBrowseStrategy.browse(template, queue, this, limit);
        if (filter != null) {
            list = (List<Exchange>) list.stream().filter(filter).collect(Collectors.toList());
        }
        return list;
    }

        public void onNick(IRCUser user, String newNick) {
            if (configuration.isOnNick()) {
                Exchange exchange = createOnNickExchange(user, newNick);
                try {
                    getProcessor().process(exchange);
                } catch (Exception e) {
                    handleException(e);
                }
            }
        }

    public static Expression bodyOgnlExpression(final String name, final String ognl) {
        return new ExpressionAdapter() {
            private ClassResolver classResolver;
            private Expression exp;
            private Language bean;

            @Override
            public Object evaluate(Exchange exchange) {
                String text = exp.evaluate(exchange, String.class);
                Class<?> type;
                try {
                    type = classResolver.resolveMandatoryClass(text);
                } catch (ClassNotFoundException e) {
                    throw CamelExecutionException.wrapCamelExecutionException(exchange, e);
                }
                Object body = exchange.getIn().getBody(type);
                if (body != null) {
                     
                     
                    Expression ognlExp = bean.createExpression(null, new Object[] { null, body, ognl });
                    ognlExp.init(exchange.getContext());
                    return ognlExp.evaluate(exchange, Object.class);
                } else {
                    return null;
                }
            }

            @Override
            public void init(CamelContext context) {
                classResolver = context.getClassResolver();
                exp = ExpressionBuilder.simpleExpression(name);
                exp.init(context);
                bean = context.resolveLanguage("bean");
            }

            @Override
            public String toString() {
                return "bodyOgnlAs[" + name + "](" + ognl + ")";
            }
        };
    }

    public void onLanguageCreated(String name, Language language) {
        Registry registry = this.camelContext.getRegistry();
        if (registry == null) {
            return;
        }

        Set<LanguageCustomizer.Policy> filters = registry.findByType(LanguageCustomizer.Policy.class);
        if (filters.isEmpty() || filters.stream().allMatch(filter -> filter.test(name, language))) {
            registry.findByType(LanguageCustomizer.class).stream()
                    .sorted(Comparator.comparingInt(Ordered::getOrder))
                    .filter(customizer -> customizer.isEnabled(name, language))
                    .forEach(customizer -> customizer.configure(name, language));
        }
    }

    protected void sendReply(
            Session session,
            Destination replyDestination, final Message message, final Exchange exchange,
            final org.apache.camel.Message out, final Exception cause) {
        if (replyDestination == null) {
            LOG.debug("Cannot send reply message as there is no replyDestination for: {}", out);
            return;
        }
        try {
            SessionCallback callback = createSessionCallback(replyDestination, message, exchange, out, cause,
                    endpoint.getJmsObjectFactory()::createMessageProducer);

            getTemplate().execute(session, callback);

        } catch (Exception e) {
            exchange.setException(new CamelExchangeException("Unable to send reply JMS message", exchange, e));
        }
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (getCamelContext().getPropertiesComponent().hasPropertiesFunction("azure")) {
            PropertiesFunction pf = getCamelContext().getPropertiesComponent().getPropertiesFunction("azure");
            if (pf instanceof KeyVaultPropertiesFunction) {
                propertiesFunction = (KeyVaultPropertiesFunction) pf;
            }
        }
        AzureVaultConfiguration azure = getCamelContext().getVaultConfiguration().getAzureVaultConfiguration();
        if (azure != null && azure.isRefreshEnabled()) {
            PeriodTaskScheduler scheduler = PluginHelper.getPeriodTaskScheduler(getCamelContext());
            secretsRefreshTask = scheduler.getTaskByType(EventhubsReloadTriggerTask.class);
        }
    }

    public Double getDouble(final String key) {
        Object returnable = this.get(key);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).doubleValue();
    }

    public Object filterResponse(Object response) {
        if (response instanceof ODataFeed) {
            response = filter((ODataFeed) response);
        } else if (response instanceof Iterable) {
            response = filter((Iterable<Object>) response);
        } else if (response.getClass().isArray()) {
            List<Object> result = new ArrayList<>();
            final int size = Array.getLength(response);
            for (int i = 0; i < size; i++) {
                result.add(Array.get(response, i));
            }
            response = filter(result);
        } else if (response instanceof ODataEntry) {
            response = filter((ODataEntry) response);
        } else {
            response = filter(response);
        }

        return response;
    }

    public static String stripSourceLocationLineNumber(String location) {
        int cnt = StringHelper.countChar(location, ':');
        if (cnt >= 1) {
            int pos = location.lastIndexOf(':');
            return location.substring(0, pos);
        } else {
            return location;
        }
    }

        boolean executeFromQueue() {
            final Runnable polled = queue != null ? queue.pollFirst() : null;
            if (polled == null) {
                return false;
            }
            try {
                decrementPendingTasks();
                if (LOG.isTraceEnabled()) {
                    LOG.trace("Running: {}", polled);
                }
                polled.run();
            } catch (Exception t) {
                 
                LOG.warn("Error executing reactive work due to {}. This exception is ignored.", t.getMessage(), t);
            }
            return true;
        }

    public static void toResult(Source source, Result result) throws TransformerException {
        if (source != null) {
            XMLConverterHelper xml = new XMLConverterHelper();
            TransformerFactory factory = xml.getTransformerFactory();
            Transformer transformer = factory.newTransformer();
            if (transformer == null) {
                throw new TransformerException("Could not create a transformer - JAXP is misconfigured!");
            } else {
                Properties outputProperties = new Properties();
                outputProperties.put("encoding", defaultCharset);
                outputProperties.put("omit-xml-declaration", "yes");

                transformer.setOutputProperties(outputProperties);
                transformer.transform(source, result);
            }
        }
    }

    public OpensearchScrollRequestIterator(SearchRequest.Builder searchRequestBuilder, OpenSearchClient esClient,
                                           int scrollKeepAliveMs, Exchange exchange, Class<TDocument> documentClass) {
         
        this.searchRequest = searchRequestBuilder
                .scroll(Time.of(b -> b.time(String.format("%sms", scrollKeepAliveMs))))
                .build();
        this.esClient = esClient;
        this.scrollKeepAliveMs = scrollKeepAliveMs;
        this.exchange = exchange;
        this.closed = false;
        this.requestCount = 0;
        this.documentClass = documentClass;

        setFirstCurrentSearchHits();
    }

    private static GenericFileExclusiveReadLockStrategy<FTPFile> getExclusiveReadLockStrategy(Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<FTPFile> strategy
                = (GenericFileExclusiveReadLockStrategy<FTPFile>) params.get("exclusiveReadLockStrategy");
        if (strategy != null) {
            return strategy;
        }

         
        String readLock = (String) params.get("readLock");
        if (ObjectHelper.isNotEmpty(readLock)) {
            if ("none".equals(readLock) || "false".equals(readLock)) {
                return null;
            } else if ("rename".equals(readLock)) {
                GenericFileRenameExclusiveReadLockStrategy<FTPFile> readLockStrategy
                        = new GenericFileRenameExclusiveReadLockStrategy<>();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            } else if ("changed".equals(readLock)) {
                FtpChangedExclusiveReadLockStrategy readLockStrategy = new FtpChangedExclusiveReadLockStrategy();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            }
        }

        return null;
    }

    public Consumer createConsumer(Processor processor) throws Exception {
        final Consumer consumer;
        if (isObserve()) {
            consumer = new CoAPObserver(this, processor);
        } else {
            consumer = new CoAPConsumer(this, processor);
        }
        configureConsumer(consumer);
        return consumer;
    }

    public KeyPair importKey(byte[] keyData, KeyFormat format, String algorithm) throws Exception {
         
        try {
            PrivateKey privateKey = KeyFormatConverter.importPrivateKey(keyData, format, getAlgorithmName(algorithm));
            LOG.warn("Importing private key only - public key derivation may be needed");
            return new KeyPair(null, privateKey);
        } catch (Exception e) {
             
            PublicKey publicKey = KeyFormatConverter.importPublicKey(keyData, format, getAlgorithmName(algorithm));
            return new KeyPair(publicKey, null);
        }
    }

                public void eventReceived(Action action, Namespace resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        JteEndpoint endpoint = new JteEndpoint(uri, this, remaining);
        endpoint.setAllowTemplateFromHeader(allowTemplateFromHeader);
        endpoint.setAllowContextMapAll(allowContextMapAll);
        endpoint.setContentCache(contentCache);

        setProperties(endpoint, parameters);

         
        if (ResourceHelper.isHttpUri(remaining)) {
            remaining = ResourceHelper.appendParameters(remaining, parameters);
            endpoint.setResourceUri(remaining);
        }

        return endpoint;
    }

    public static QueryBuilder query(final String query) {
        return new QueryBuilder() {
            protected Query makeQueryObject(EntityManager entityManager) {
                return entityManager.createQuery(query);
            }

            @Override
            public String toString() {
                return "Query: " + query + getParameterDescription();
            }
        };
    }

    public Integer getIntegerOrDefault(final String key, final int defaultValue) {
        Object returnable;
        if (this.containsKey(key)) {
            returnable = this.get(key);
        } else {
            return defaultValue;
        }
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).intValue();
    }

    protected Message loadDefaultInstance(final String className, final CamelContext context)
            throws CamelException, ClassNotFoundException {
        Class<?> instanceClass = context.getClassResolver().resolveMandatoryClass(className);
        if (Message.class.isAssignableFrom(instanceClass)) {
            try {
                Method method = instanceClass.getMethod("getDefaultInstance");
                return (Message) method.invoke(null);
            } catch (final Exception ex) {
                throw new CamelException(
                        "Can't set the defaultInstance of ProtobufferDataFormat with " + className + ", caused by " + ex);
            }
        } else {
            throw new CamelException(
                    "Can't set the defaultInstance of ProtobufferDataFormat with " + className
                                     + ", as the class is not a subClass of com.google.protobuf.Message");
        }
    }

    public String apply(String remainder) {
        String key = remainder;
        String defaultValue = null;

        if (remainder.contains(":")) {
            key = StringHelper.before(remainder, ":");
            defaultValue = StringHelper.after(remainder, ":");
        }

         
        if (key != null) {
             
            key = key.toUpperCase(Locale.ENGLISH).replace('-', '_');

             
            String host = IOHelper.lookupEnvironmentVariable(key + HOST_PREFIX);
            String port = IOHelper.lookupEnvironmentVariable(key + PORT_PREFIX);

            if (host != null && port != null) {
                return host + ":" + port;
            } else {
                return defaultValue;
            }
        }

        return defaultValue;
    }

    public ConvertVariableProcessor(String name, Expression variableName, String toName, Expression toVariableName,
                                    Class<?> type, String charset, boolean mandatory) {
        ObjectHelper.notNull(variableName, "variableName");
        ObjectHelper.notNull(type, "type", this);
        this.name = name;
        this.variableName = variableName;
        this.toName = toName;
        this.toVariableName = toVariableName;
        this.type = type;
        this.charset = IOHelper.normalizeCharset(charset);
        this.mandatory = mandatory;
    }

    private JsonObject asJsonObject(DevConsoleModel model) {
        JsonObject jo = new JsonObject();
         
        jo.put("kind", "console");
        if (model.group != null) {
            jo.put("group", model.getGroup());
        } else {
            jo.put("group", "camel");
        }
        jo.put("name", model.getName());
        if (model.getDisplayName() != null) {
            jo.put("title", asTitle(model.getDisplayName()));
        } else {
            jo.put("title", asTitle(model.getName()));
        }
        jo.put("description", model.getDescription());
        jo.put("deprecated", model.isDeprecated());
        jo.put("javaType", model.getClassName());
        jo.put("groupId", project.getGroupId());
        jo.put("artifactId", project.getArtifactId());
        jo.put("version", project.getVersion());
        JsonObject root = new JsonObject();
        root.put("console", jo);
        return root;
    }

    public ActiveMQQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    public static <T> Optional<T> firstNotNull(ThrowingSupplier<T, Exception>... suppliers) throws Exception {
        T answer = null;

        for (ThrowingSupplier<T, Exception> supplier : suppliers) {
            answer = supplier.get();
            if (answer != null) {
                break;
            }
        }

        return Optional.ofNullable(answer);
    }

    public HealthCheck resolveHealthCheck(String id) {
         
        HealthCheck answer = camelContext.getRegistry().lookupByNameAndType(id + "-health-check", HealthCheck.class);
        if (answer == null) {
            answer = camelContext.getRegistry().lookupByNameAndType(id, HealthCheck.class);
        }
        if (answer != null) {
            return answer;
        }

        Class<?> type = null;
        try {
            type = findHealthCheck(id, camelContext);
        } catch (NoFactoryAvailableException e) {
             
        } catch (Exception e) {
            throw new IllegalArgumentException("Invalid URI, no HealthCheck registered for id: " + id, e);
        }

        if (type != null) {
            if (HealthCheck.class.isAssignableFrom(type)) {
                return (HealthCheck) camelContext.getInjector().newInstance(type, false);
            } else {
                throw new IllegalArgumentException(
                        "Resolving health-check: " + id + " detected type conflict: Not a HealthCheck implementation. Found: "
                                                   + type.getName());
            }
        }

        return null;
    }

    public void run() {
        startingTime = Instant.now();
        final CountDownLatch isWatchClosed = new CountDownLatch(1);
        Watch watch = kubernetesClient.configMaps().inNamespace(kubernetesClient.getNamespace()).watch(new Watcher<>() {
            @Override
            public void eventReceived(Action action, ConfigMap configMap) {
                switch (action.name()) {
                    case "MODIFIED":
                        if (isReloadEnabled()) {
                            if (matchSecret(configMap.getMetadata().getName())) {
                                LOG.info("Update for Kubernetes Configmaps: {} detected, triggering CamelContext reload",
                                        configMap.getMetadata().getName());
                                ContextReloadStrategy reload = camelContext.hasService(ContextReloadStrategy.class);
                                if (reload != null) {
                                     
                                    reload.onReload(this);
                                }
                            }
                        }
                        break;
                    default:
                        LOG.debug("Not watched event {}", action.name());
                }
            }

            @Override
            public void onClose(WatcherException e) {
                isWatchClosed.countDown();
            }
        });

         
        try {
            isWatchClosed.await();
        } catch (InterruptedException e) {
            LOG.debug("Interrupted while waiting for the watch to close: {}", e.getMessage());
            Thread.currentThread().interrupt();
        }
        watch.close();
    }

    public XmlStreamReader(final InputStream is, final String httpContentType, final boolean lenient,
                           final String defaultEncoding) throws IOException, XmlStreamReaderException {
        if (defaultEncoding == null) {
            this.defaultEncoding = staticDefaultEncoding;
        } else {
            this.defaultEncoding = defaultEncoding;
        }
        try {
            doHttpStream(is, httpContentType, lenient);
        } catch (final XmlStreamReaderException ex) {
            if (!lenient) {
                throw ex;
            } else {
                doLenientDetection(httpContentType, ex);
            }
        }
    }

    public String slaves() {
        if (groupListener == null) {
            return null;
        }
        try {
            return new ObjectMapper()
                    .enable(SerializationFeature.INDENT_OUTPUT)
                    .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES)
                    .writeValueAsString(groupListener.getGroup().slaves());
        } catch (Exception e) {
            return null;
        }
    }

    private <T extends IBaseBundle> void processOptionalParams(
            Integer count, Date theCutoff, IPrimitiveType<Date> cutoff, IHistoryTyped<T> tiHistoryTyped) {
        if (count != null) {
            tiHistoryTyped.count(count);
        }
        if (theCutoff != null) {
            tiHistoryTyped.since(theCutoff);
        }
        if (cutoff != null) {
            tiHistoryTyped.since(cutoff);
        }
    }

    protected boolean isInputStreamNeededForObject(Object obj) {
        if (obj == null) {
            return false;
        }

        if (obj instanceof WrappedFile) {
            obj = ((WrappedFile<?>) obj).getFile();
        }
        if (obj instanceof File) {
             
             
            return true;
        }

         
        return false;
    }

    protected void decode(
            ChannelHandlerContext ctx, AddressedEnvelope<Object, InetSocketAddress> msg,
            List<Object> out)
            throws Exception {
        if (msg.content() instanceof ByteBuf) {
            ByteBuf payload = (ByteBuf) msg.content();
            Object result = delegateDecoder.decode(ctx, payload);
            AddressedEnvelope<Object, InetSocketAddress> addressEvelop
                    = new DefaultAddressedEnvelope<>(result, msg.recipient(), msg.sender());
            out.add(addressEvelop);
        } else {
            LOG.debug("Ignoring message content as it is not an io.netty.buffer.ByteBuf instance.");
        }
    }

    public void setupJacksonXml(
            CamelContext camelContext, RestConfiguration config,
            String type, Class<?> typeClass, String outType, Class<?> outTypeClass,
            DataFormat xml, DataFormat outXml)
            throws Exception {
         
        PropertyConfigurer configurer = PluginHelper.getConfigurerResolver(camelContext)
                .resolvePropertyConfigurer("jacksonXml-dataformat-configurer", camelContext);
        if (configurer == null) {
            throw new IllegalStateException("Cannot find configurer for dataformat: jacksonXml");
        }

         
         
         

        PropertyBindingSupport.Builder builder = PropertyBindingSupport.build()
                .withCamelContext(camelContext)
                .withConfigurer(configurer)
                .withTarget(xml);

        final String typeName = getTypeName(type, typeClass);
        if (typeName != null) {
            builder.withProperty("unmarshalTypeName", typeName);
        }

        setAdditionalConfiguration(config, "xml.in.", builder);
        builder.bind();

         
         
         

        PropertyBindingSupport.Builder outBuilder = PropertyBindingSupport.build()
                .withCamelContext(camelContext)
                .withConfigurer(configurer)
                .withTarget(outXml);

        final String outTypeName = getOutTypeName(outType, outTypeClass, typeName);

        if (outTypeName != null) {
            outBuilder.withProperty("unmarshalTypeName", outTypeName);
        }

        setAdditionalConfiguration(config, "xml.out.", outBuilder);
        outBuilder.bind();
    }

    void logUsageSummary(Logger log, String name, int pooled) {
        if (statisticsEnabled && consumer != null) {
             
            long created = statistics.getCreatedCounter();
            long acquired = statistics.getAcquiredCounter();
            long released = statistics.getReleasedCounter();
            long discarded = statistics.getDiscardedCounter();
            boolean shouldLog = pooled > 0 || created > 0 || acquired > 0 || released > 0 || discarded > 0;
            if (shouldLog) {
                String id = getRouteId();
                if (id == null) {
                    id = "";
                } else {
                    id = " " + id;
                }
                String uri = consumer.getEndpoint().getEndpointBaseUri();
                uri = URISupport.sanitizeUri(uri);

                 
                boolean leak = created + acquired > released + discarded;
                if (leak) {
                    long leaks = (created + acquired) - (released + discarded);
                    log.warn(
                            "{}{} ({}) usage (leaks detected: {}) [pooled: {}, created: {}, acquired: {}, released: {}, discarded: {}]",
                            name, id, uri, leaks, pooled, created, acquired, released, discarded);
                } else {
                    log.info("{}{} ({}) usage [pooled: {}, created: {}, acquired: {}, released: {}, discarded: {}]",
                            name, id, uri, pooled, created, acquired, released, discarded);
                }
            }
        }
    }

    private void doUpdateList(Exchange exchange, SqlSession session) {
        Object result;
        Object in = getInput(exchange);
        if (in != null) {
             
            LOG.trace("Updating: {} using statement: {}", in, statement);
            result = session.update(statement, in);
            doProcessResult(exchange, result, session);
        } else {
            LOG.trace("Updating using statement: {}", statement);
            result = session.update(statement);
            doProcessResult(exchange, result, session);
        }
    }

    public DynamicRouterEndpoint(final String uri, final DynamicRouterComponent component,
                                 final DynamicRouterConfiguration configuration,
                                 final Supplier<DynamicRouterProcessorFactory> processorFactorySupplier,
                                 final Supplier<DynamicRouterProducerFactory> producerFactorySupplier,
                                 final BiFunction<CamelContext, Expression, RecipientList> recipientListSupplier,
                                 final DynamicRouterFilterService filterService) {
        super(uri, component);
        this.channel = configuration.getChannel();
        this.configuration = configuration;
        this.processorFactorySupplier = processorFactorySupplier;
        this.producerFactorySupplier = producerFactorySupplier;
        this.recipientListSupplier = recipientListSupplier;
        this.configuration.setChannel(channel);
        this.filterService = filterService;
        LOG.debug("Created Dynamic Router endpoint URI: {}", uri);
    }

    protected void doStop() throws Exception {
        super.doStop();

        LOG.debug("Stopping OpenShift DeploymentConfigs Consumer");
        if (executor != null) {
            KubernetesHelper.close(deploymentsWatcher, deploymentsWatcher::getWatch);

            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownNow(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    protected void doCall(Map<String, Object> options, Function<ManagedRouteMBean, Object> task) {
        String path = (String) options.get(Exchange.HTTP_PATH);
        String subPath = path != null ? StringHelper.after(path, "/") : null;
        String filter = (String) options.get(FILTER);
        String limit = (String) options.get(LIMIT);
        final int max = limit == null ? Integer.MAX_VALUE : Integer.parseInt(limit);

        ManagedCamelContext mcc = getCamelContext().getCamelContextExtension().getContextPlugin(ManagedCamelContext.class);
        if (mcc != null) {
            List<Route> routes = getCamelContext().getRoutes();
            routes.sort((o1, o2) -> o1.getRouteId().compareToIgnoreCase(o2.getRouteId()));
            routes.stream()
                    .map(route -> mcc.getManagedRoute(route.getRouteId()))
                    .filter(Objects::nonNull)
                    .filter(r -> accept(r, filter))
                    .filter(r -> accept(r, subPath))
                    .sorted(RouteDumpDevConsole::sort)
                    .limit(max)
                    .forEach(task::apply);
        }
    }

    public void interceptProperties(Map<String, Object> properties) {
        Map<String, String> endpointHttpHeaders = (Map<String, String>) properties.get(ENDPOINT_HTTP_HEADERS_PROPERTY);

         
        properties.put(EDM_PROPERTY, apiProxy.getEdm(endpointHttpHeaders));

         
        properties.put(FILTER_ALREADY_SEEN, configuration.isFilterAlreadySeen());

         
        final String keyPredicate = (String) properties.get(KEY_PREDICATE_PROPERTY);
        if (keyPredicate != null) {

             
            properties.compute(RESOURCE_PATH_PROPERTY, (key, resourcePath) -> {
                if (resourcePath == null) {
                    throw new IllegalArgumentException(
                            "Resource path must be provided in endpoint URI, or URI parameter '" + RESOURCE_PATH_PROPERTY
                                                       + "', or exchange header '"
                                                       + Olingo4Constants.PROPERTY_PREFIX + RESOURCE_PATH_PROPERTY + "'");
                }

                 
                return resourcePath + "(" + keyPredicate + ")";
            });
        }

         
        parseQueryParams(properties);
    }

    protected void doParse(Element element, BeanDefinitionBuilder builder) {
        NamedNodeMap attributes = element.getAttributes();
        for (int x = 0; x < attributes.getLength(); x++) {
            Attr attribute = (Attr) attributes.item(x);
            String name = attribute.getLocalName();
            String fullName = attribute.getName();
             
            if (fullName.equals("id") && isAssignId()) {
                if (attribute.getValue() != null) {
                    builder.addPropertyValue("id", attribute.getValue());
                }
                 
            } else if (!fullName.startsWith("xmlns:") && !fullName.equals("xmlns") && isEligibleAttribute(name)) {
                String propertyName = extractPropertyName(name);
                Assert.state(StringUtils.hasText(propertyName),
                        "Illegal property name returned from 'extractPropertyName(String)': cannot be null or empty.");
                builder.addPropertyValue(propertyName, attribute.getValue());
            }
        }
        postProcess(builder, element);
    }

private int jjMoveStringLiteralDfa3_0(long old0, long active0){
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(1, old0);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(2, active0);
      return 3;
   }
   switch(curChar)
   {
      case 32:
         if ((active0 & 0x4L) != 0L)
            return jjStopAtPos(3, 2);
         break;
      case 85:
         return jjMoveStringLiteralDfa4_0(active0, 0x8L);
      default :
         break;
   }
   return jjStartNfa_0(2, active0);
}

    protected void initRouteTemplateRefs() throws Exception {
         
        if (getRouteTemplateRefs() != null) {
            for (RouteTemplateContextRefDefinition ref : getRouteTemplateRefs()) {
                List<RouteTemplateDefinition> defs = ref.lookupRouteTemplates(getContext());
                for (RouteTemplateDefinition def : defs) {
                    LOG.debug("Adding route template from {} -> {}", ref, def);
                    getRouteTemplates().add(def);
                }
            }
        }
    }

    private XPathFunction createOutHeaderFunction() {
        return new XPathFunction() {
            @SuppressWarnings("rawtypes")
            public Object evaluate(List list) throws XPathFunctionException {
                if (exchange.get() != null && !list.isEmpty()) {
                    Object value = list.get(0);
                    if (value != null) {
                        String headerText = exchange.get().getContext().getTypeConverter().convertTo(String.class, value);
                        return exchange.get().getOut().getHeader(headerText);
                    }
                }
                return null;
            }
        };
    }

    public static Map<String, Object> asMap(Node node) {
        if (node == null) {
            return null;
        }

        final MappingNode mn = asMappingNode(node);
        final Map<String, Object> answer = new HashMap<>();

        for (NodeTuple tuple : mn.getValue()) {
            final String key = asText(tuple.getKeyNode());
            final Node val = tuple.getValueNode();

            switch (val.getNodeType()) {
                case SCALAR:
                    answer.put(StringHelper.dashToCamelCase(key), asText(val));
                    break;
                case MAPPING:
                    answer.put(StringHelper.dashToCamelCase(key), asMap(val));
                    break;
                default:
                    throw new UnsupportedNodeTypeException(val);
            }
        }

        return answer;
    }

    protected String getFrom(Row r) {
        String u = r.from;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    private void doPublish(Exchange exchange, AsyncCallback callback) {
        Object body = exchange.getIn().getBody();
        if (ObjectHelper.isEmpty(body)) {
            throw new RuntimeCamelException("Cannot publish empty message");
        }
        LOG.debug("Sending message [{}] to channel [{}]", body, getChannel(exchange));
        endpoint.getPubnub()
                .publish()
                .message(body)
                .channel(getChannel(exchange))
                .usePOST(true)
                .async((Result<PNPublishResult> result) -> {
                    LOG.debug("Got publish message [{}]", result);
                    if (result.isFailure()) {
                        PubNubException ex = result.exceptionOrNull();
                        if (ex != null) {
                            exchange.setException(ex);
                        }
                        callback.done(false);
                    } else {
                        PNPublishResult r = result.getOrNull();
                        if (r != null) {
                            exchange.getIn().setHeader(PubNubConstants.TIMETOKEN, r.getTimetoken());
                        }
                        processMessage(exchange, callback, null);
                    }
                });
    }

    private void processGetQueryResultIds(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String jobId;
        BatchInfo batchBody;
        String batchId;
        batchBody = exchange.getIn().getBody(BatchInfo.class);
        if (batchBody != null) {
            jobId = batchBody.getJobId();
            batchId = batchBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
            batchId = getParameter(BATCH_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getQueryResultIds(jobId, batchId, determineHeaders(exchange), new BulkApiClient.QueryResultIdsCallback() {
            @Override
            public void onResponse(List<String> ids, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, ids, headers, ex, callback);
            }
        });
    }

    protected String getHttpURL(Exchange exchange, Endpoint endpoint) {
        Object url = exchange.getIn().getHeader(Exchange.HTTP_URL);
        if (url instanceof String) {
            return (String) url;
        } else {
            Object uri = exchange.getIn().getHeader(Exchange.HTTP_URI);
            if (uri instanceof String) {
                return (String) uri;
            } else {
                 
                int index = endpoint.getEndpointUri().lastIndexOf("http:");
                if (index != -1) {
                    return endpoint.getEndpointUri().substring(index);
                }
            }
        }
        return null;
    }

    public TrustManagersParameters getObject() throws Exception {
        if (isSingleton()) {
            if (instance == null) {
                instance = createInstance();
            }
            return instance;
        } else {
            return createInstance();
        }
    }

    public ProcessResponse cancelProcessInstance(ProcessRequest processMessage) {
        ProcessResponse resultMessage = new ProcessResponse();
        resultMessage.setProcessInstanceKey(processMessage.getProcessInstanceKey());

        try {
            GatewayGrpc.GatewayBlockingStub stub = GatewayGrpc.newBlockingStub(managedChannel);
            GatewayOuterClass.CancelProcessInstanceResponse cancelProcessInstanceResponse
                    = stub.cancelProcessInstance(GatewayOuterClass.CancelProcessInstanceRequest.newBuilder()
                            .setProcessInstanceKey(processMessage.getProcessInstanceKey())
                            .build());

            resultMessage.setSuccess(true);
        } catch (StatusRuntimeException exception) {
            LOG.error(String.format("Cannot cancel process instance %s", processMessage.getProcessId()), exception);
            resultMessage.setErrorMessage(exception.getMessage());
            resultMessage.setErrorCode(exception.getStatus().toString());
            resultMessage.setSuccess(false);
        }

        return resultMessage;
    }

    private Function<Exchange, Object> saveEdge() {
        return exchange -> {
            try {
                ArangoEdgeCollection edgeCollection = calculateEdgeCollection();
                Object edgeDocument = exchange.getMessage().getMandatoryBody();
                return edgeCollection.insertEdge(edgeDocument);
            } catch (InvalidPayloadException e) {
                throw new RuntimeCamelException(INVALID_PAYLOAD_MESSAGE, e);
            }
        };
    }

    public void getQueryResult(
            String jobId, String batchId, String resultId, Map<String, List<String>> headers,
            final StreamResponseCallback callback) {
        final Request get = getRequest(HttpMethod.GET, batchResultUrl(jobId, batchId, resultId), headers);

         
        doHttpRequest(get, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                callback.onResponse(response, headers, ex);
            }
        });
    }

    public static EvictionType getEvictionType(String name) {
        if (name == null) {
            return null;
        }
        for (EvictionType evictionType : VALUES) {
            if (evictionType.toString().equalsIgnoreCase(name) || evictionType.name().equalsIgnoreCase(name)) {
                return evictionType;
            }
        }
        throw new IllegalArgumentException(String.format("Eviction type '%s' is not supported by this component.", name));
    }

    public OperationResult<Boolean> getResult() {
        try {
            connection.delete(node, version);
            if (LOG.isDebugEnabled()) {
                if (LOG.isTraceEnabled()) {
                    LOG.trace(format("Set data of node '%s'", node));
                } else {
                    LOG.debug(format("Set data of node '%s'", node));
                }
            }
            return new OperationResult<>(true, null, true);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return new OperationResult<>(e);
        } catch (Exception e) {
            return new OperationResult<>(e);
        }
    }

    private void closeInput(Message message) {
        InputStream is = message.getContent(InputStream.class);
        if (is != null) {
            try {
                is.close();
                message.removeContent(InputStream.class);
            } catch (IOException ioex) {
                 
            }
        }
    }

    protected void halfOpenCircuit(Route route) {
        try {
            lock.lock();
            resumeOrStartConsumer(route.getConsumer());
            state.set(STATE_HALF_OPEN);
            logState();
        } catch (Exception e) {
            handleException(e);
        } finally {
            lock.unlock();
        }
    }

    private void insertMeasurements(Exchange exchange, String orgName, String bucketName, WritePrecision writePrecision)
            throws InvalidPayloadException {
        Measurements measurements = exchange.getIn().getMandatoryBody(Measurements.class);
        try {
            if (LOG.isDebugEnabled()) {
                LOG.debug("Writing measurements {}", measurements);
            }
            writeApi.writeMeasurements(bucketName, orgName, writePrecision, measurements.getInfluxMeasurements());
        } catch (Exception ex) {
            exchange.setException(new CamelInfluxDb2Exception(ex));
        }
    }

    protected Configuration createConnectorConfiguration() {
        final Configuration.Builder configBuilder = Configuration.create();
        
        addPropertyIfNotNull(configBuilder, "transaction.metadata.factory", transactionMetadataFactory);
        addPropertyIfNotNull(configBuilder, "streaming.delay.ms", streamingDelayMs);
        addPropertyIfNotNull(configBuilder, "custom.metric.tags", customMetricTags);
        addPropertyIfNotNull(configBuilder, "mongodb.connection.string", mongodbConnectionString);
        addPropertyIfNotNull(configBuilder, "mongodb.password", mongodbPassword);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.namespace", openlineageIntegrationJobNamespace);
        addPropertyIfNotNull(configBuilder, "query.fetch.size", queryFetchSize);
        addPropertyIfNotNull(configBuilder, "signal.enabled.channels", signalEnabledChannels);
        addPropertyIfNotNull(configBuilder, "mongodb.ssl.enabled", mongodbSslEnabled);
        addPropertyIfNotNull(configBuilder, "cursor.max.await.time.ms", cursorMaxAwaitTimeMs);
        addPropertyIfNotNull(configBuilder, "field.renames", fieldRenames);
        addPropertyIfNotNull(configBuilder, "mongodb.server.selection.timeout.ms", mongodbServerSelectionTimeoutMs);
        addPropertyIfNotNull(configBuilder, "poll.interval.ms", pollIntervalMs);
        addPropertyIfNotNull(configBuilder, "guardrail.collections.max", guardrailCollectionsMax);
        addPropertyIfNotNull(configBuilder, "signal.data.collection", signalDataCollection);
        addPropertyIfNotNull(configBuilder, "converters", converters);
        addPropertyIfNotNull(configBuilder, "heartbeat.topics.prefix", heartbeatTopicsPrefix);
        addPropertyIfNotNull(configBuilder, "mongodb.connect.timeout.ms", mongodbConnectTimeoutMs);
        addPropertyIfNotNull(configBuilder, "snapshot.fetch.size", snapshotFetchSize);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.tags", openlineageIntegrationJobTags);
        addPropertyIfNotNull(configBuilder, "mongodb.poll.interval.ms", mongodbPollIntervalMs);
        addPropertyIfNotNull(configBuilder, "incremental.snapshot.watermarking.strategy", incrementalSnapshotWatermarkingStrategy);
        addPropertyIfNotNull(configBuilder, "mongodb.user", mongodbUser);
        addPropertyIfNotNull(configBuilder, "heartbeat.interval.ms", heartbeatIntervalMs);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.on.schema.error", snapshotModeConfigurationBasedSnapshotOnSchemaError);
        addPropertyIfNotNull(configBuilder, "snapshot.collection.filter.overrides", snapshotCollectionFilterOverrides);
        addPropertyIfNotNull(configBuilder, "field.exclude.list", fieldExcludeList);
        addPropertyIfNotNull(configBuilder, "errors.max.retries", errorsMaxRetries);
        addPropertyIfNotNull(configBuilder, "database.exclude.list", databaseExcludeList);
        addPropertyIfNotNull(configBuilder, "max.batch.size", maxBatchSize);
        addPropertyIfNotNull(configBuilder, "skipped.operations", skippedOperations);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.description", openlineageIntegrationJobDescription);
        addPropertyIfNotNull(configBuilder, "topic.naming.strategy", topicNamingStrategy);
        addPropertyIfNotNull(configBuilder, "snapshot.mode", snapshotMode);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.data", snapshotModeConfigurationBasedSnapshotData);
        addPropertyIfNotNull(configBuilder, "extended.headers.enabled", extendedHeadersEnabled);
        addPropertyIfNotNull(configBuilder, "max.queue.size", maxQueueSize);
        addPropertyIfNotNull(configBuilder, "guardrail.collections.limit.action", guardrailCollectionsLimitAction);
        addPropertyIfNotNull(configBuilder, "custom.sanitize.pattern", customSanitizePattern);
        addPropertyIfNotNull(configBuilder, "collection.include.list", collectionIncludeList);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.owners", openlineageIntegrationJobOwners);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.config.file.path", openlineageIntegrationConfigFilePath);
        addPropertyIfNotNull(configBuilder, "retriable.restart.connector.wait.ms", retriableRestartConnectorWaitMs);
        addPropertyIfNotNull(configBuilder, "capture.mode", captureMode);
        addPropertyIfNotNull(configBuilder, "snapshot.delay.ms", snapshotDelayMs);
        addPropertyIfNotNull(configBuilder, "executor.shutdown.timeout.ms", executorShutdownTimeoutMs);
        addPropertyIfNotNull(configBuilder, "provide.transaction.metadata", provideTransactionMetadata);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.on.data.error", snapshotModeConfigurationBasedSnapshotOnDataError);
        addPropertyIfNotNull(configBuilder, "schema.history.internal.file.filename", schemaHistoryInternalFileFilename);
        addPropertyIfNotNull(configBuilder, "tombstones.on.delete", tombstonesOnDelete);
        addPropertyIfNotNull(configBuilder, "topic.prefix", topicPrefix);
        addPropertyIfNotNull(configBuilder, "sourceinfo.struct.maker", sourceinfoStructMaker);
        addPropertyIfNotNull(configBuilder, "mongodb.authsource", mongodbAuthsource);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.dataset.kafka.bootstrap.servers", openlineageIntegrationDatasetKafkaBootstrapServers);
        addPropertyIfNotNull(configBuilder, "collection.exclude.list", collectionExcludeList);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.enabled", openlineageIntegrationEnabled);
        addPropertyIfNotNull(configBuilder, "snapshot.include.collection.list", snapshotIncludeCollectionList);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.start.stream", snapshotModeConfigurationBasedStartStream);
        addPropertyIfNotNull(configBuilder, "max.queue.size.in.bytes", maxQueueSizeInBytes);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.schema", snapshotModeConfigurationBasedSnapshotSchema);
        addPropertyIfNotNull(configBuilder, "signal.poll.interval.ms", signalPollIntervalMs);
        addPropertyIfNotNull(configBuilder, "post.processors", postProcessors);
        addPropertyIfNotNull(configBuilder, "notification.enabled.channels", notificationEnabledChannels);
        addPropertyIfNotNull(configBuilder, "mongodb.socket.timeout.ms", mongodbSocketTimeoutMs);
        addPropertyIfNotNull(configBuilder, "event.processing.failure.handling.mode", eventProcessingFailureHandlingMode);
        addPropertyIfNotNull(configBuilder, "snapshot.max.threads", snapshotMaxThreads);
        addPropertyIfNotNull(configBuilder, "notification.sink.topic.name", notificationSinkTopicName);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.custom.name", snapshotModeCustomName);
        addPropertyIfNotNull(configBuilder, "schema.name.adjustment.mode", schemaNameAdjustmentMode);
        addPropertyIfNotNull(configBuilder, "mongodb.ssl.invalid.hostname.allowed", mongodbSslInvalidHostnameAllowed);
        addPropertyIfNotNull(configBuilder, "mongodb.heartbeat.frequency.ms", mongodbHeartbeatFrequencyMs);
        addPropertyIfNotNull(configBuilder, "connection.validation.timeout.ms", connectionValidationTimeoutMs);
        addPropertyIfNotNull(configBuilder, "database.include.list", databaseIncludeList);
        
        return configBuilder.build();
    }

    private void describeCluster(EksClient eksClient, Exchange exchange) throws InvalidPayloadException {
        executeOperation(
                exchange,
                DescribeClusterRequest.class,
                eksClient::describeCluster,
                () -> {
                    String clusterName = getRequiredHeader(exchange, EKS2Constants.CLUSTER_NAME, String.class,
                            "Cluster name must be specified");
                    return eksClient.describeCluster(DescribeClusterRequest.builder().name(clusterName).build());
                },
                "Describe Cluster",
                (DescribeClusterResponse response, Message message) -> {
                    if (response.cluster() != null) {
                        message.setHeader(EKS2Constants.CLUSTER_ARN, response.cluster().arn());
                    }
                });
    }

    protected void prepareDataFormatConfig(Map<String, Object> properties) {
        properties.put("prettyPrint", definition.getPrettyPrint());
        properties.put("objectFactory", definition.getObjectFactory());
        properties.put("ignoreJAXBElement", definition.getIgnoreJAXBElement());
        properties.put("mustBeJAXBElement", definition.getMustBeJAXBElement());
        properties.put("filterNonXmlChars", definition.getFilterNonXmlChars());
        properties.put("fragment", definition.getFragment());
        properties.put("contextPath", definition.getContextPath());
        properties.put("contextPathIsClassName", definition.getContextPathIsClassName());
        properties.put("partClass", definition.getPartClass());
        properties.put("partNamespace", definition.getPartNamespace());
        properties.put("encoding", definition.getEncoding());
        properties.put("namespacePrefix", asRef(definition.getNamespacePrefix()));
        properties.put("schema", definition.getSchema());
        properties.put("schemaSeverityLevel", definition.getSchemaSeverityLevel());
        properties.put("xmlStreamWriterWrapper", definition.getXmlStreamWriterWrapper());
        properties.put("schemaLocation", definition.getSchemaLocation());
        properties.put("noNamespaceSchemaLocation", definition.getNoNamespaceSchemaLocation());
        properties.put("jaxbProviderProperties", definition.getJaxbProviderProperties());
        properties.put("accessExternalSchemaProtocols", definition.getAccessExternalSchemaProtocols());
    }

    protected void doDeleteTag(String operation) throws GitAPIException {
        if (ObjectHelper.isEmpty(endpoint.getTagName())) {
            throw new IllegalArgumentException("Tag Name must be specified to execute " + operation);
        }
        try {
            git.tagDelete().setTags(endpoint.getTagName()).call();
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
    }

    public Exchange create(Endpoint fromEndpoint, boolean autoRelease) {
        Exchange exchange = pool.poll();
        if (exchange == null) {
             
            exchange = createPooledExchange(fromEndpoint, autoRelease);
            if (statisticsEnabled) {
                statistics.created.increment();
            }
        } else {
            if (statisticsEnabled) {
                statistics.acquired.increment();
            }
        }

         
        ((ResetableClock) exchange.getClock()).reset();

        return exchange;
    }

    public Processor toProcessor(final MessageListener listener) {
        return new Processor() {
            public void process(Exchange exchange) throws Exception {
                Message message = toMessage(exchange);
                listener.onMessage(message);
            }

            @Override
            public String toString() {
                return "Processor of MessageListener: " + listener;
            }
        };
    }

                public void onComplete(Exchange exchange) {
                     
                    Boolean close;
                    if (ExchangeHelper.isOutCapable(exchange)) {
                        close = exchange.getOut().getHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, Boolean.class);
                    } else {
                        close = exchange.getIn().getHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, Boolean.class);
                    }

                     
                    boolean disconnect = getConfiguration().isDisconnect();
                    if (close != null) {
                        disconnect = close;
                    }

                    if (disconnect) {
                        LOG.trace("Closing channel {} as routing the Exchange is done", channel);
                        NettyHelper.close(channel);
                    }

                    releaseChannel(channelFuture);
                }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();
        if (propertiesFunction != null) {
            root.put("login", "Client Id/Client Secret");
            AzureVaultConfiguration azure = getCamelContext().getVaultConfiguration().getAzureVaultConfiguration();
            if (azure != null) {
                root.put("refreshEnabled", azure.isRefreshEnabled());
                root.put("refreshPeriod", azure.getRefreshPeriod());
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastCheckTimestamp", timestamp);
                    root.put("lastCheckAge", TimeUtils.printSince(timestamp));
                }
                last = secretsRefreshTask.getLastReloadTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastReloadTimestamp", timestamp);
                    root.put("lastReloadAge", TimeUtils.printSince(timestamp));
                }
            }
            JsonArray arr = new JsonArray();
            root.put("secrets", arr);

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                JsonObject jo = new JsonObject();
                jo.put("name", sec);
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    jo.put("timestamp", timestamp);
                    jo.put("age", TimeUtils.printSince(timestamp));
                }
                arr.add(jo);
            }
        }
        return root;
    }

    public Producer createProducer() throws Exception {
        validate();
        JpaProducer producer = new JpaProducer(this, getProducerExpression());
        producer.setQuery(getQuery());
        producer.setNamedQuery(getNamedQuery());
        producer.setNativeQuery(getNativeQuery());
        producer.setParameters(getParameters());
        producer.setResultClass(getResultClass());
        producer.setFindEntity(isFindEntity());
        producer.setUseExecuteUpdate(getUseExecuteUpdate());
        return producer;
    }

    public static String camelCaseToDash(String text) {
        if (text == null || text.isEmpty()) {
            return text;
        }
        char prev = 0;

        char[] arr = text.toCharArray();
        StringBuilder answer = new StringBuilder(arr.length < 13 ? 16 : arr.length + 8);

        for (int i = 0; i < arr.length; i++) {
            char ch = arr[i];

            if (ch == '-' || ch == '_') {
                answer.append("-");
            } else {
                if (Character.isUpperCase(ch) && prev != 0) {
                    char next;

                    if (i < arr.length - 1) {
                        next = arr[i + 1];
                    } else {
                        next = 0;
                    }

                    if (!Character.isUpperCase(prev) || next != 0 && Character.isLowerCase(next)) {
                        applyDashPrefix(prev, answer, ch);
                    } else {
                        answer.append(Character.toLowerCase(ch));
                    }
                } else {
                    answer.append(Character.toLowerCase(ch));
                }
            }
            prev = ch;
        }

        return answer.toString();
    }

            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                List<ReportInstance> reportInstances = null;
                if (response != null) {
                    try {
                        reportInstances = unmarshalResponse(response, request, TypeReferences.REPORT_INSTANCE_LIST_TYPE);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(reportInstances, headers, ex);
            }

    public KeyPair generateKeyPair(String algorithm, String keyId, Object parameterSpec) throws Exception {
        LOG.info("Generating key pair for algorithm: {}, keyId: {}", algorithm, keyId);

        KeyPairGenerator generator;
        String provider = determineProvider(algorithm);

        if (provider != null) {
            generator = KeyPairGenerator.getInstance(getAlgorithmName(algorithm), provider);
        } else {
            generator = KeyPairGenerator.getInstance(getAlgorithmName(algorithm));
        }

         
        if (parameterSpec != null) {
            if (parameterSpec instanceof AlgorithmParameterSpec) {
                generator.initialize((AlgorithmParameterSpec) parameterSpec, new SecureRandom());
            } else if (parameterSpec instanceof Integer) {
                generator.initialize((Integer) parameterSpec, new SecureRandom());
            }
        } else {
             
            AlgorithmParameterSpec defaultSpec = getDefaultParameterSpec(algorithm);
            if (defaultSpec != null) {
                generator.initialize(defaultSpec, new SecureRandom());
            } else {
                generator.initialize(getDefaultKeySize(algorithm), new SecureRandom());
            }
        }

        KeyPair keyPair = generator.generateKeyPair();

         
        KeyMetadata metadata = new KeyMetadata(keyId, algorithm);
        metadata.setDescription("Generated on " + new Date());

         
        storeKey(keyId, keyPair, metadata);

        LOG.info("Generated key pair in AWS Secrets Manager: {}", metadata);
        return keyPair;
    }

    private void createSetVariableDefinitions(Object[] variableNamesAndExprs) {
        if (variableNamesAndExprs.length == 1 && variableNamesAndExprs[0] instanceof Map) {
            createVariablesFromMap((Map<?, ?>) variableNamesAndExprs[0]);
        } else if (variableNamesAndExprs.length % 2 != 0) {
            throw new IllegalArgumentException("Must be a Map or have an even number of arguments!");
        } else {
            for (int i = 0; i < variableNamesAndExprs.length; i += 2) {
                addVariable(variableNamesAndExprs[i], variableNamesAndExprs[i + 1]);
            }
        }
    }

    public static JsonObject asJsonObject(MainModel model) {
        JsonObject json = new JsonObject();
        JsonArray groups = new JsonArray();
        for (MainGroupModel group : model.getGroups()) {
            JsonObject j = new JsonObject();
            j.put("name", group.getName());
            if (group.getDescription() != null) {
                j.put("description", group.getDescription());
            }
            if (group.getSourceType() != null) {
                j.put("sourceType", group.getSourceType());
            }
            groups.add(j);
        }
        json.put("groups", groups);
        JsonArray props = new JsonArray();
        for (MainOptionModel prop : model.getOptions()) {
            JsonObject j = new JsonObject();
            j.put("name", prop.getName());
            j.put("required", prop.isRequired());
            if (prop.getDescription() != null) {
                j.put("description", prop.getDescription());
            }
            if (prop.getGroup() != null) {
                j.put("group", prop.getGroup());
            }
            if (prop.getLabel() != null) {
                j.put("label", prop.getLabel());
            }
            if (prop.getSourceType() != null) {
                j.put("sourceType", prop.getSourceType());
            }
            j.put("type", prop.getType());
            j.put("javaType", prop.getJavaType());
            if (prop.getDefaultValue() != null) {
                j.put("defaultValue", prop.resolveDefaultValue());
            }
            j.put("secret", prop.isSecret());
            if (prop.getEnums() != null) {
                j.put("enum", prop.getEnums());
            }
            if (prop.isDeprecated()) {
                j.put("deprecated", prop.isDeprecated());
            }
            if (prop.isAutowired()) {
                j.put("autowired", prop.isAutowired());
            }
            props.add(j);
        }
        json.put("properties", props);
        return json;
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (meterRegistry == null) {
            meterRegistry = MicrometerUtils.getOrCreateMeterRegistry(camelContext.getRegistry(), METRICS_REGISTRY_NAME);
        }

        try {
            MicrometerEventNotifierService registryService = camelContext.hasService(MicrometerEventNotifierService.class);
            if (registryService == null) {
                registryService = new MicrometerEventNotifierService();
                registryService.setMeterRegistry(getMeterRegistry());
                registryService.setPrettyPrint(isPrettyPrint());
                registryService.setSkipCamelInfo(isSkipCamelInfo());
                registryService.setDurationUnit(getDurationUnit());
                registryService.setMatchingTags(Tags.of(KIND, KIND_EXCHANGE));
                camelContext.addService(registryService);
                 
                ServiceHelper.startService(registryService);
            }
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    protected void doPush(Exchange exchange, String operation) throws GitAPIException {
        Iterable<PushResult> result = null;
        try {
            if (ObjectHelper.isEmpty(endpoint.getRemoteName())) {
                throw new IllegalArgumentException("Remote name must be specified to execute " + operation);
            }
            if (ObjectHelper.isNotEmpty(endpoint.getBranchName())) {
                git.checkout().setCreateBranch(false).setName(endpoint.getBranchName()).call();
            }
            if (ObjectHelper.isNotEmpty(endpoint.getUsername()) && ObjectHelper.isNotEmpty(endpoint.getPassword())) {
                UsernamePasswordCredentialsProvider credentials
                        = new UsernamePasswordCredentialsProvider(endpoint.getUsername(), endpoint.getPassword());
                result = git.push().setCredentialsProvider(credentials).setRemote(endpoint.getRemoteName()).call();
            } else {
                result = git.push().setRemote(endpoint.getRemoteName()).call();
            }
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
        updateExchange(exchange, result);
    }

    public void setLoggingFeatureEnabled(boolean loggingFeatureEnabled) {
        if (loggingFeature != null) {
            getFeatures().remove(loggingFeature);
            loggingFeature = null;
        }
        if (loggingFeatureEnabled) {
            if (getLoggingSizeLimit() > 0) {
                loggingFeature = new LoggingFeature();
                loggingFeature.setLimit(getLoggingSizeLimit());
            } else {
                loggingFeature = new LoggingFeature();
            }
            getFeatures().add(loggingFeature);
        }

    }

    <T> Optional<T> tryToReadResponse(final Class<T> expectedType, final InputStream responseStream) {
        if (responseStream == null) {
            return Optional.empty();
        }
        try {
            return Optional.of(fromJson(expectedType, responseStream));
        } catch (IOException e) {
            log.warn("Unable to read response from the Composite API", e);
            return Optional.empty();
        } finally {
            IOHelper.close(responseStream);
        }
    }

    public int getPort() {
        if (uri.getPort() == -1) {
            if ("cometds".equals(getProtocol())) {
                return 443;
            } else {
                return 80;
            }
        }
        return uri.getPort();
    }

    private CommitCmd executeCommitContainerRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Commit Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);

        ObjectHelper.notNull(containerId, MISSING_CONTAINER_ID);

        CommitCmd commitCmd = client.commitCmd(containerId);

        String author = DockerHelper.getProperty(DockerConstants.DOCKER_AUTHOR, configuration, message, String.class);

        if (author != null) {
            commitCmd.withAuthor(author);
        }

        Boolean attachStdErr
                = DockerHelper.getProperty(DockerConstants.DOCKER_ATTACH_STD_ERR, configuration, message, Boolean.class);

        if (attachStdErr != null) {
            commitCmd.withAttachStderr(attachStdErr);
        }

        Boolean attachStdIn
                = DockerHelper.getProperty(DockerConstants.DOCKER_ATTACH_STD_IN, configuration, message, Boolean.class);

        if (attachStdIn != null) {
            commitCmd.withAttachStdin(attachStdIn);
        }

        Boolean attachStdOut
                = DockerHelper.getProperty(DockerConstants.DOCKER_ATTACH_STD_OUT, configuration, message, Boolean.class);

        if (attachStdOut != null) {
            commitCmd.withAttachStdout(attachStdOut);
        }

        String[] cmds = DockerHelper.parseDelimitedStringHeader(DockerConstants.DOCKER_CMD, message);

        if (cmds != null) {
            commitCmd.withCmd(cmds);
        }

        Boolean disableNetwork
                = DockerHelper.getProperty(DockerConstants.DOCKER_DISABLE_NETWORK, configuration, message, Boolean.class);

        if (disableNetwork != null) {
            commitCmd.withDisableNetwork(disableNetwork);
        }

        String[] envs = DockerHelper.parseDelimitedStringHeader(DockerConstants.DOCKER_ENV, message);

        if (envs != null) {
            commitCmd.withEnv(envs);
        }

        ExposedPorts exposedPorts
                = DockerHelper.getProperty(DockerConstants.DOCKER_EXPOSED_PORTS, configuration, message, ExposedPorts.class);

        if (exposedPorts != null) {
            commitCmd.withExposedPorts(exposedPorts);
        }

        String hostname = DockerHelper.getProperty(DockerConstants.DOCKER_HOSTNAME, configuration, message, String.class);

        if (hostname != null) {
            commitCmd.withHostname(hostname);
        }

        Integer memory = DockerHelper.getProperty(DockerConstants.DOCKER_MEMORY, configuration, message, Integer.class);

        if (memory != null) {
            commitCmd.withMemory(memory);
        }

        Integer memorySwap
                = DockerHelper.getProperty(DockerConstants.DOCKER_MEMORY_SWAP, configuration, message, Integer.class);

        if (memorySwap != null) {
            commitCmd.withMemorySwap(memorySwap);
        }

        String msg = DockerHelper.getProperty(DockerConstants.DOCKER_MESSAGE, configuration, message, String.class);

        if (msg != null) {
            commitCmd.withMessage(msg);
        }

        Boolean openStdIn = DockerHelper.getProperty(DockerConstants.DOCKER_OPEN_STD_IN, configuration, message, Boolean.class);

        if (openStdIn != null) {
            commitCmd.withOpenStdin(openStdIn);
        }

        Boolean pause = DockerHelper.getProperty(DockerConstants.DOCKER_PAUSE, configuration, message, Boolean.class);

        if (pause != null) {
            commitCmd.withPause(pause);
        }

        String[] portSpecs = DockerHelper.parseDelimitedStringHeader(DockerConstants.DOCKER_PORT_SPECS, message);

        if (portSpecs != null) {
            commitCmd.withPortSpecs(portSpecs);
        }

        String repository = DockerHelper.getProperty(DockerConstants.DOCKER_REPOSITORY, configuration, message, String.class);

        if (repository != null) {
            commitCmd.withRepository(repository);
        }

        Boolean stdInOnce = DockerHelper.getProperty(DockerConstants.DOCKER_STD_IN_ONCE, configuration, message, Boolean.class);

        if (stdInOnce != null) {
            commitCmd.withStdinOnce(stdInOnce);
        }

        String tag = DockerHelper.getProperty(DockerConstants.DOCKER_TAG, configuration, message, String.class);

        if (tag != null) {
            commitCmd.withTag(tag);
        }

        Boolean tty = DockerHelper.getProperty(DockerConstants.DOCKER_TTY, configuration, message, Boolean.class);

        if (tty != null) {
            commitCmd.withTty(tty);
        }

        String user = DockerHelper.getProperty(DockerConstants.DOCKER_USER, configuration, message, String.class);

        if (user != null) {
            commitCmd.withUser(user);
        }

        Volumes volumes = DockerHelper.getProperty(DockerConstants.DOCKER_VOLUMES, configuration, message, Volumes.class);

        if (volumes != null) {
            commitCmd.withVolumes(volumes);
        }

        String workingDir = DockerHelper.getProperty(DockerConstants.DOCKER_WORKING_DIR, configuration, message, String.class);

        if (workingDir != null) {
            commitCmd.withWorkingDir(workingDir);
        }

        return commitCmd;

    }

    public void deleteJob(String jobId, Map<String, List<String>> headers, ResponseCallback callback) {
        final Request request = getRequest(HttpMethod.DELETE, jobUrl(jobId), headers);
        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                callback.onResponse(headers, ex);
            }
        });
    }

    protected Connector getSocketConnector(Server server, JettyHttpEndpoint endpoint) {
        Connector answer = null;
        if (socketConnectors != null) {
            answer = socketConnectors.get(endpoint.getPort());
        }
        if (answer == null) {
            answer = createConnector(server, endpoint);
        }
        return answer;
    }

    protected void afterConfigureProperties() {
        olingo4endpointPropertyNames
                = new HashSet<>(getPropertiesHelper().getValidEndpointProperties(getCamelContext(), configuration));
        olingo4endpointPropertyNames.add(EDM_PROPERTY);
        olingo4endpointPropertyNames.add(ENDPOINT_HTTP_HEADERS_PROPERTY);
        olingo4endpointPropertyNames.add(SERVICE_URI_PROPERTY);
        olingo4endpointPropertyNames.add(FILTER_ALREADY_SEEN);

         
        if (!(READ_METHOD.equals(methodName) || DELETE_METHOD.equals(methodName) || UREAD_METHOD.equals(methodName))
                && inBody == null) {
            inBody = DATA_PROPERTY;
        }
        createProxy();
    }

    public <T> Map<String, T> findByTypeWithName(Class<T> type) {
        Map<String, T> result = new HashMap<>();
         
        String keyPrefix = type.getName().replace('$', '/');
        kvClient = consul.keyValueClient();

        List<String> keys;
        try {
            keys = kvClient.getKeys(keyPrefix);
        } catch (ConsulException e) {
            return result;
        }

        if (keys != null) {
            Object obj;

            for (String key : keys) {
                 
                key = key.substring(key.lastIndexOf('/') + 1);
                obj = lookupByName(key.replace('$', '/'));
                if (type.isInstance(obj)) {
                    result.put(key, type.cast(obj));
                }
            }
        }
        return result;
    }

    public static <I1, I2, T extends Throwable> BiConsumer<I1, I2> wrapAsBiConsumer(ThrowingBiConsumer<I1, I2, T> consumer) {
        return new BiConsumer<>() {
            @Override
            public void accept(I1 i1, I2 i2) {
                try {
                    consumer.accept(i1, i2);
                } catch (Throwable t) {
                    throw new RuntimeException(t);
                }
            }
        };
    }

    private String parseTopicName(String uri) {
         
        uri = uri.replaceFirst(scheme + "://", ":");
        uri = StringHelper.before(uri, "?", uri);

         
        int pos = uri.indexOf(':');
        if (pos != -1) {
            return uri.substring(pos + 1);
        } else {
            return null;
        }
    }

    public static String getCharsetFromExchange(Exchange exchange) {
        String charset = null;
        if (exchange != null) {
            String contentType = exchange.getMessage().getHeader(VertxHttpConstants.CONTENT_TYPE, String.class);
            charset = IOHelper.getCharsetNameFromContentType(contentType);
            if (ObjectHelper.isEmpty(charset)) {
                charset = exchange.getProperty(ExchangePropertyKey.CHARSET_NAME, String.class);
            }
        }
        return charset;
    }

    public Task schedule(BackOff backOff, ThrowingFunction<Task, Boolean, Exception> function) {
        final BackOffTimerTask task = new BackOffTimerTask(this, backOff, scheduler, function);

        long delay = task.next();
        if (delay != BackOff.NEVER) {
            tasks.add(task);
            scheduler.schedule(task, delay, TimeUnit.MILLISECONDS);
        } else {
            task.cancel();
        }

        return task;
    }

    private static GenericFileExclusiveReadLockStrategy<File> newStrategyForIdempotentChanged(
            Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<File> strategy;
        FileIdempotentChangedRepositoryReadLockStrategy readLockStrategy
                = new FileIdempotentChangedRepositoryReadLockStrategy();
        Boolean readLockRemoveOnRollback = (Boolean) params.get("readLockRemoveOnRollback");
        if (readLockRemoveOnRollback != null) {
            readLockStrategy.setRemoveOnRollback(readLockRemoveOnRollback);
        }
        Boolean readLockRemoveOnCommit = (Boolean) params.get("readLockRemoveOnCommit");
        if (readLockRemoveOnCommit != null) {
            readLockStrategy.setRemoveOnCommit(readLockRemoveOnCommit);
        }
        IdempotentRepository repo = (IdempotentRepository) params.get("readLockIdempotentRepository");
        if (repo != null) {
            readLockStrategy.setIdempotentRepository(repo);
        }
        Long minLength = (Long) params.get("readLockMinLength");
        if (minLength != null) {
            readLockStrategy.setMinLength(minLength);
        }
        Long minAge = (Long) params.get("readLockMinAge");
        if (null != minAge) {
            readLockStrategy.setMinAge(minAge);
        }
        Integer readLockIdempotentReleaseDelay = (Integer) params.get("readLockIdempotentReleaseDelay");
        if (readLockIdempotentReleaseDelay != null) {
            readLockStrategy.setReadLockIdempotentReleaseDelay(readLockIdempotentReleaseDelay);
        }
        Boolean readLockIdempotentReleaseAsync = (Boolean) params.get("readLockIdempotentReleaseAsync");
        if (readLockIdempotentReleaseAsync != null) {
            readLockStrategy.setReadLockIdempotentReleaseAsync(readLockIdempotentReleaseAsync);
        }
        Integer readLockIdempotentReleaseAsyncPoolSize = (Integer) params.get("readLockIdempotentReleaseAsyncPoolSize");
        if (readLockIdempotentReleaseAsyncPoolSize != null) {
            readLockStrategy.setReadLockIdempotentReleaseAsyncPoolSize(readLockIdempotentReleaseAsyncPoolSize);
        }
        ScheduledExecutorService readLockIdempotentReleaseExecutorService
                = (ScheduledExecutorService) params.get("readLockIdempotentReleaseExecutorService");
        if (readLockIdempotentReleaseExecutorService != null) {
            readLockStrategy.setReadLockIdempotentReleaseExecutorService(readLockIdempotentReleaseExecutorService);
        }
        strategy = readLockStrategy;
        return strategy;
    }

    public static Expression fileSizeExpression() {
        return new ExpressionAdapter() {
            @Override
            public Object evaluate(Exchange exchange) {
                return exchange.getIn().getHeader(Exchange.FILE_LENGTH, Long.class);
            }

            @Override
            public String toString() {
                return "file:length";
            }
        };
    }

    private void doSelectOne(Exchange exchange, SqlSession session) {
        Object result;
        Object in = getInput(exchange);
        if (in != null) {
            LOG.trace("SelectOne: {} using statement: {}", in, statement);
            result = session.selectOne(statement, in);
        } else {
            LOG.trace("SelectOne using statement: {}", statement);
            result = session.selectOne(statement);
        }

        doProcessResult(exchange, result, session);
    }

    protected DirectConsumer getConsumer(String key, boolean block, long timeout) throws InterruptedException {
        consumersLock.lock();
        try {
            DirectConsumer answer = consumers.get(key);
            if (answer == null && block) {
                StopWatch watch = new StopWatch();
                for (;;) {
                    answer = consumers.get(key);
                    if (answer != null) {
                        break;
                    }
                    long rem = timeout - watch.taken();
                    if (rem <= 0) {
                        break;
                    }
                    consumersCondition.await(rem, TimeUnit.MILLISECONDS);
                }
            }
            return answer;
        } finally {
            consumersLock.unlock();
        }
    }

    private void generateJavaClass() {
        setPackage();
        setImports();
        setClassNameAndType();
        setClassFields();
        setSettersAndGettersMethods();
        setCreateConnectorConfigurationMethod();
        setConfigureConnectorClassMethod();
        setValidateConnectorConfiguration();
        setGetConnectorDatabaseType();
    }

    public void initAnnotatedFields() {

        for (Class<?> cl : models) {

            List<Field> linkFields = new ArrayList<>();

            if (LOG.isDebugEnabled()) {
                LOG.debug("Class retrieved: {}", cl.getName());
            }

            for (Field field : cl.getDeclaredFields()) {
                DataField dataField = field.getAnnotation(DataField.class);
                if (dataField != null) {

                    if (LOG.isDebugEnabled()) {
                        LOG.debug("Position defined in the class: {}, position: {}, Field: {}", cl.getName(), dataField.pos(),
                                dataField);
                    }

                    if (dataField.required()) {
                        ++numberMandatoryFields;
                    } else {
                        ++numberOptionalFields;
                    }

                    dataFields.put(dataField.pos(), dataField);
                    annotatedFields.put(dataField.pos(), field);
                }

                Link linkField = field.getAnnotation(Link.class);

                if (linkField != null) {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("Class linked: {}, Field: {}", cl.getName(), field);
                    }
                    linkFields.add(field);
                }

            }

            if (!linkFields.isEmpty()) {
                annotatedLinkFields.put(cl.getName(), linkFields);
            }

            totalFields = numberMandatoryFields + numberOptionalFields;

            if (LOG.isDebugEnabled()) {
                LOG.debug("Number of optional fields: {}", numberOptionalFields);
                LOG.debug("Number of mandatory fields: {}", numberMandatoryFields);
                LOG.debug("Total: {}", totalFields);
            }

        }
    }

    public void onBeginDownloading(String host, String file) {
        download = true;
        resume = false;
        resumeOffset = 0;
        watch.restart();
        interval.restart();
        String msg = "Downloading from host: " + host + " file: " + file + " starting ";  
                                                                                         
                                                                                         
                                                                                         
                                                                                         
                                                                                         
                                                                                         
        if (fileSize > 0) {
            msg += " (size: " + fileSizeText + ")";
        }
        doLog(msg);
    }

    public boolean register(PlatformHttpPlugin plugin) {
        if (getPlugin(plugin.getId()).isPresent()) {
            return false;
        }

        boolean result = plugins.add(plugin);
        if (result) {
            CamelContextAware.trySetCamelContext(plugin, camelContext);
            ServiceHelper.startService(plugin);
            LOG.debug("platform-http-plugin with id {} successfully registered", plugin.getId());
        }
        return result;
    }

        public Float parse(String string) throws Exception {
            float value;
            if (!super.hasImpliedDecimalPosition()) {
                value = Float.parseFloat(string.trim());
            } else {
                BigDecimal tmp = new BigDecimal(string.trim());
                BigDecimal div = BigDecimal.valueOf(super.getMultiplier());
                value = tmp.divide(div).floatValue();
            }

            return value;
        }

    public Producer createProducer(
            CamelContext camelContext, String host,
            String verb, String basePath, String uriTemplate, String queryParameters,
            String consumes, String produces, RestConfiguration configuration, Map<String, Object> parameters)
            throws Exception {

         
        basePath = FileUtil.stripLeadingSeparator(basePath);
        uriTemplate = FileUtil.stripLeadingSeparator(uriTemplate);

         
        String url = host;
        if (!ObjectHelper.isEmpty(basePath)) {
            url += "/" + basePath;
        }
        if (!ObjectHelper.isEmpty(uriTemplate)) {
            url += "/" + uriTemplate;
        }

        RestConfiguration config = configuration;
        if (config == null) {
            config = CamelContextHelper.getRestConfiguration(getCamelContext(), null, "http");
        }

        Map<String, Object> map = new HashMap<>();
         
        if (config.getProducerComponent() == null || config.getProducerComponent().equals("http")) {
             
            map.put("httpMethod", verb);
            if (config.getEndpointProperties() != null && !config.getEndpointProperties().isEmpty()) {
                map.putAll(config.getEndpointProperties());
            }
        }

        url = HttpUtil.recreateUrl(map, url);

        parameters = parameters != null ? new HashMap<>(parameters) : new HashMap<>();

         
         
         
        RestProducerFactoryHelper.setupComponentFor(url, camelContext, (Map<String, Object>) parameters.remove("component"));

        HttpEndpoint endpoint = (HttpEndpoint) camelContext.getEndpoint(url, parameters);

        String path = uriTemplate != null ? uriTemplate : basePath;

        HeaderFilterStrategy headerFilterStrategy
                = resolveAndRemoveReferenceParameter(parameters, "headerFilterStrategy", HeaderFilterStrategy.class);
        if (headerFilterStrategy != null) {
            endpoint.setHeaderFilterStrategy(headerFilterStrategy);
        } else {
            endpoint.setHeaderFilterStrategy(new HttpRestHeaderFilterStrategy(path, queryParameters));
        }
         
        ServiceHelper.startService(endpoint);

        return endpoint.createProducer();
    }

    public String getLastFtpActivity() {
        FTPClient client = getOperations().getFtpClient();
        FtpClientActivityListener listener = (FtpClientActivityListener) client.getCopyStreamListener();
        if (listener != null) {
            String log = listener.getLastLogActivity();
            if (log != null) {
                long since = listener.getLastLogActivityTimestamp();
                if (since > 0) {
                    String human = TimeUtils.printSince(since);
                    return log + " " + human + " ago";
                } else {
                    return log;
                }
            }
        }
        return null;
    }

    protected Message doNext() {
        if (parent == null) {
            parent = getNextElement();
        }
        Message answer = parent;
        parent = null;
        currentEntry = null;

        if (first && answer == null) {
            throw new IllegalStateException("Unable to unzip the file, it may be corrupted.");
        }

        first = false;
        checkNullAnswer(answer);

        return answer;
    }

    public Processor createErrorHandler(Processor processor) throws Exception {
         
        TransactionTemplate transactionTemplate = resolveTransactionTemplate(definition);
        ObjectHelper.notNull(transactionTemplate, "transactionTemplate", this);

         
        RedeliveryPolicy redeliveryPolicy = resolveRedeliveryPolicy(definition, camelContext);
        CamelLogger logger = resolveLogger(definition);
        LoggingLevel rollbackLoggingLevel = resolveRollbackLoggingLevel(definition);

        TransactionErrorHandler answer = new TransactionErrorHandler(
                camelContext, processor, logger,
                getProcessor(definition.getOnRedeliveryProcessor(), definition.getOnRedeliveryRef()),
                redeliveryPolicy,
                transactionTemplate,
                resolveRetryWhilePolicy(definition, camelContext),
                getExecutorService(definition.getExecutorServiceBean(), definition.getExecutorServiceRef()),
                rollbackLoggingLevel,
                getProcessor(definition.getOnExceptionOccurredProcessor(), definition.getOnExceptionOccurredRef()));
         
        configure(answer);
        return answer;
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            MicrometerObservationSpanAdapter camelSpan = (MicrometerObservationSpanAdapter) ActiveSpanManager.getSpan(exchange);
            if (camelSpan != null) {
                String item = camelSpan.getContextPropagationItem(keyName);
                exchange.getMessage().setHeader(headerName, item);
            } else {
                LOG.warn("Micrometer Observation: Cannot find managed span for exchange: {}", exchange);
            }
        } catch (Exception e) {
            exchange.setException(e);
        } finally {
             
            callback.done(true);
        }

        return true;
    }

    private static String getTypeName(String type, Class<?> typeClass) {
        String typeName = null;
        if (typeClass != null) {
            typeName = typeClass.isArray() ? typeClass.getComponentType().getName() : typeClass.getName();
        } else if (type != null) {
            typeName = type.endsWith("[]") ? type.substring(0, type.length() - 2) : type;
        }
        return typeName;
    }

            public boolean process(Exchange exchange, AsyncCallback callback) {
                Map<String, String> previousContext = MDC.getCopyOfContextMap();
                mdcService.setMDC(exchange);
                return asyncProcessor.process(exchange, doneSync -> {
                    try {
                        callback.done(doneSync);
                    } finally {
                        mdcService.unsetMDC(exchange);
                        if (previousContext != null) {
                            MDC.setContextMap(previousContext);
                        } else {
                            MDC.clear();
                        }
                    }
                });
            }

    public void createJob(JobInfo request, Map<String, List<String>> headers, final JobInfoResponseCallback callback) {
         
        sanitizeJobRequest(request);

        final Request post = getRequest(HttpMethod.POST, jobUrl(null), headers);
        try {
            marshalRequest(objectFactory.createJobInfo(request), post, APPLICATION_XML_UTF8);
        } catch (Exception e) {
            callback.onResponse(null, Collections.emptyMap(), new SalesforceException(e));
            return;
        }

         
        doHttpRequest(post, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                JobInfo value = null;
                if (response != null) {
                    try {
                        value = unmarshalResponse(response, post, JobInfo.class);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(value, headers, ex);
            }
        });
    }

    List<Long> findPids(String name) {
        List<Long> pids = new ArrayList<>();

         
        if (name.matches("\\d+")) {
            return List.of(Long.parseLong(name));
        } else {
            if (name.endsWith("!")) {
                 
                name = name.substring(0, name.length() - 1);
            } else if (!name.endsWith("*")) {
                 
                name = name + "*";
            }
        }

        final long cur = ProcessHandle.current().pid();
        final String pattern = name;
        ProcessHandle.allProcesses()
                .filter(ph -> ph.pid() != cur)
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        String pName = ProcessHelper.extractName(root, ph);
                         
                        pName = FileUtil.onlyName(pName);
                        if (pName != null && !pName.isEmpty() && PatternHelper.matchPattern(pName, pattern)) {
                            pids.add(ph.pid());
                        } else {
                             
                            JsonObject context = (JsonObject) root.get("context");
                            if (context != null) {
                                pName = context.getString("name");
                                if ("CamelJBang".equals(pName)) {
                                    pName = null;
                                }
                                if (pName != null && !pName.isEmpty() && PatternHelper.matchPattern(pName, pattern)) {
                                    pids.add(ph.pid());
                                }
                            }
                        }
                    }
                });

        return pids;
    }

    private Element findEncryptedDataElement(Element element) {
         
        if (EncryptionConstants._TAG_ENCRYPTEDDATA.equals(element.getLocalName())
                && EncryptionConstants.EncryptionSpecNS.equals(element.getNamespaceURI())) {
            return element;
        }

         
        Node child = element.getFirstChild();
        while (child != null) {
            if (child.getNodeType() == Node.ELEMENT_NODE) {
                Element childElement = (Element) child;
                if (EncryptionConstants._TAG_ENCRYPTEDDATA.equals(childElement.getLocalName())
                        && EncryptionConstants.EncryptionSpecNS.equals(childElement.getNamespaceURI())) {
                    return childElement;
                }
            }
            child = child.getNextSibling();
        }

        return null;
    }

    public boolean contains(final String key) {
         
        Boolean rc = transactionTemplate.execute(new TransactionCallback<Boolean>() {
            public Boolean doInTransaction(TransactionStatus status) {
                int count = queryForInt(key);
                if (count == 0) {
                    return Boolean.FALSE;
                } else {
                    return Boolean.TRUE;
                }
            }
        });
        return rc.booleanValue();

    }

    protected HazelcastInstance getOrCreateHzInstance(CamelContext context, Map<String, Object> parameters) throws Exception {
        HazelcastInstance hzInstance = null;
        Config config = null;

         
        hzInstance = resolveAndRemoveReferenceParameter(parameters, HAZELCAST_INSTANCE_PARAM, HazelcastInstance.class);

         
        if (hzInstance == null && parameters.get(HAZELCAST_INSTANCE_NAME_PARAM) != null) {
            hzInstance = Hazelcast.getHazelcastInstanceByName((String) parameters.get(HAZELCAST_INSTANCE_NAME_PARAM));
        }

         
         
        if (hzInstance == null) {
            config = resolveAndRemoveReferenceParameter(parameters, HAZELCAST_CONFIGU_PARAM, Config.class);
            if (config == null) {
                String configUri = getAndRemoveParameter(parameters, HAZELCAST_CONFIGU_URI_PARAM, String.class);
                if (configUri != null) {
                    configUri = getCamelContext().resolvePropertyPlaceholders(configUri);
                }
                if (configUri != null) {
                    InputStream is = ResourceHelper.resolveMandatoryResourceAsInputStream(context, configUri);
                    config = new XmlConfigBuilder(is).build();
                }
            }

            if (hazelcastInstance == null && config == null) {
                config = new XmlConfigBuilder().build();
                 
                config.getProperties().setProperty("hazelcast.version.check.enabled", "false");
                config.getProperties().setProperty("hazelcast.phone.home.enabled", "false");

                hzInstance = Hazelcast.newHazelcastInstance(config);
            } else if (config != null) {
                if (ObjectHelper.isNotEmpty(config.getInstanceName())) {
                    hzInstance = Hazelcast.getOrCreateHazelcastInstance(config);
                } else {
                    hzInstance = Hazelcast.newHazelcastInstance(config);
                }
            }

            if (hzInstance != null) {
                if (this.customHazelcastInstances.add(hzInstance)) {
                    LOGGER.debug("Add managed HZ instance {}", hzInstance.getName());
                }
            }
        }

        return hzInstance == null ? hazelcastInstance : hzInstance;
    }

    public boolean hasNext() {
        if (closed) {
            return false;
        }

        boolean answer = it.hasNext();
        if (!answer) {
             
            try {
                close();
            } catch (IOException e) {
                 
            }
        }
        return answer;
    }

    protected CancelSm createCancelSm(Exchange exchange) {
        Message in = exchange.getIn();
        CancelSm cancelSm = new CancelSm();

        if (in.getHeaders().containsKey(SmppConstants.ID)) {
            cancelSm.setMessageId(in.getHeader(SmppConstants.ID, String.class));
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR)) {
            cancelSm.setSourceAddr(in.getHeader(SmppConstants.SOURCE_ADDR, String.class));
        } else {
            cancelSm.setSourceAddr(config.getSourceAddr());
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR_TON)) {
            cancelSm.setSourceAddrTon(in.getHeader(SmppConstants.SOURCE_ADDR_TON, Byte.class));
        } else {
            cancelSm.setSourceAddrTon(config.getSourceAddrTon());
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR_NPI)) {
            cancelSm.setSourceAddrNpi(in.getHeader(SmppConstants.SOURCE_ADDR_NPI, Byte.class));
        } else {
            cancelSm.setSourceAddrNpi(config.getSourceAddrNpi());
        }

        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR)) {
            cancelSm.setDestinationAddress(in.getHeader(SmppConstants.DEST_ADDR, String.class));
        } else {
            cancelSm.setDestinationAddress(config.getDestAddr());
        }

        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR_TON)) {
            cancelSm.setDestAddrTon(in.getHeader(SmppConstants.DEST_ADDR_TON, Byte.class));
        } else {
            cancelSm.setDestAddrTon(config.getDestAddrTon());
        }

        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR_NPI)) {
            cancelSm.setDestAddrNpi(in.getHeader(SmppConstants.DEST_ADDR_NPI, Byte.class));
        } else {
            cancelSm.setDestAddrNpi(config.getDestAddrNpi());
        }

        if (in.getHeaders().containsKey(SmppConstants.SERVICE_TYPE)) {
            cancelSm.setServiceType(in.getHeader(SmppConstants.SERVICE_TYPE, String.class));
        } else {
            cancelSm.setServiceType(config.getServiceType());
        }

        return cancelSm;
    }

    public void process(Exchange exchange) throws Exception {

        ClientConfigurations clientConfigurations = new ClientConfigurations();

        if (this.iamClient == null) {
            LOG.info("Initializing SDK client");
            this.iamClient = endpoint.initClient();
            LOG.info("IAM client initialized");
        }

        updateClientConfigs(exchange, clientConfigurations);

        switch (clientConfigurations.getOperation()) {
            case IAMOperations.LIST_USERS:
                listUsers(exchange);
                break;
            case IAMOperations.GET_USER:
                getUser(exchange, clientConfigurations);
                break;
            case IAMOperations.UPDATE_USER:
                updateUser(exchange, clientConfigurations);
                break;
            case IAMOperations.LIST_GROUPS:
                listGroups(exchange);
                break;
            case IAMOperations.GET_GROUP_USERS:
                getGroupUsers(exchange, clientConfigurations);
                break;
            case IAMOperations.UPDATE_GROUP:
                updateGroup(exchange, clientConfigurations);
                break;
            default:
                throw new UnsupportedOperationException(
                        String.format("%s is not a supported operation", clientConfigurations.getOperation()));
        }
    }

    public void setSigPolicyIdDocumentationReferences(List<String> sigPolicyIdDocumentationReferences) {
        if (sigPolicyIdDocumentationReferences == null) {
            throw new IllegalArgumentException("Parameter 'sigPolicyIdDocumentationReferences' is null");
        }
        for (String ref : sigPolicyIdDocumentationReferences) {
            if (ref == null || ref.isEmpty()) {
                throw new IllegalArgumentException(
                        "At least one documentation reference of the signature policy is null or empty");
            }
        }
        this.sigPolicyIdDocumentationReferences = sigPolicyIdDocumentationReferences;
    }

    private void bulkDeleteUsers(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        List<String> userIds = exchange.getIn().getHeader(KeycloakConstants.USER_IDS, List.class);
        if (userIds == null || userIds.isEmpty()) {
             
            List<String> usernames = exchange.getIn().getHeader(KeycloakConstants.USERNAMES, List.class);
            if (usernames == null || usernames.isEmpty()) {
                 
                Object payload = exchange.getIn().getBody();
                if (payload instanceof List) {
                    userIds = CastUtils.cast((List<?>) payload);
                } else {
                    throw new IllegalArgumentException("User IDs or usernames must be provided via header or body");
                }
            } else {
                 
                userIds = new ArrayList<>();
                for (String username : usernames) {
                    List<UserRepresentation> foundUsers
                            = keycloakClient.realm(realmName).users().searchByUsername(username, true);
                    if (!foundUsers.isEmpty()) {
                        userIds.add(foundUsers.get(0).getId());
                    }
                }
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

        for (String userId : userIds) {
            Map<String, Object> result = new HashMap<>();
            result.put("userId", userId);
            try {
                Response response = keycloakClient.realm(realmName).users().delete(userId);
                result.put("status", "success");
                result.put("statusCode", response.getStatus());
                successCount++;
                response.close();
            } catch (Exception e) {
                result.put("status", "failed");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to delete user: " + userId, e);
                }
            }
            results.add(result);
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", userIds.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    public void start() {
        lock.lock();
        try {
            if (status == STARTED) {
                logger().trace("Service: {} already started", this);
                return;
            }
            if (status == STARTING) {
                logger().trace("Service: {} already starting", this);
                return;
            }
            init();
            if (status == FAILED) {
                logger().trace("Init failed");
                return;
            }
            try (AutoCloseable ignored = doLifecycleChange()) {
                status = STARTING;
                logger().trace("Starting service: {}", this);
                doStart();
                status = STARTED;
                logger().trace("Started service: {}", this);
            } catch (Exception e) {
                 
                try {
                    stop();
                } catch (Exception e2) {
                     
                    logger().trace("Error while stopping service after it failed to start: {}. This exception is ignored",
                            this, e);
                }
                logger().trace("Error while starting service: {}", this, e);
                fail(e);
            }
        } finally {
            lock.unlock();
        }
    }

    private void deleteFunction(CloudFunctionsServiceClient client, Exchange exchange)
            throws InvalidPayloadException, InterruptedException, ExecutionException {
        Empty response = null;
        if (getConfiguration().isPojoRequest()) {
            DeleteFunctionRequest request = exchange.getIn().getMandatoryBody(DeleteFunctionRequest.class);
            response = client.deleteFunctionAsync(request).get();
        } else {
            CloudFunctionName cfName = CloudFunctionName.of(getConfiguration().getProject(),
                    getConfiguration().getLocation(), getConfiguration().getFunctionName());
            DeleteFunctionRequest request = DeleteFunctionRequest.newBuilder().setName(cfName.toString()).build();
            response = client.deleteFunctionAsync(request).get();
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(response);
    }

    private Acceptor createAcceptor(
            Application application, SessionSettings settings,
            MessageStoreFactory messageStoreFactory, LogFactory sessionLogFactory,
            MessageFactory messageFactory, ThreadModel threadModel)
            throws ConfigError {

        Acceptor acceptor;
        if (threadModel == ThreadModel.ThreadPerSession) {
            acceptor = new ThreadedSocketAcceptor(
                    application, messageStoreFactory, settings, sessionLogFactory, messageFactory);
        } else if (threadModel == ThreadModel.ThreadPerConnector) {
            acceptor = new SocketAcceptor(application, messageStoreFactory, settings, sessionLogFactory, messageFactory);
        } else {
            throw new ConfigError("Unknown thread mode: " + threadModel);
        }
        return acceptor;
    }

    public DocFlavor forMimeTypePCL(String flavor) {
        if (flavor.equalsIgnoreCase("DocFlavor.BYTE_ARRAY")) {
            d = DocFlavor.BYTE_ARRAY.PCL;
        } else if (flavor.equalsIgnoreCase("DocFlavor.INPUT_STREAM")) {
            d = DocFlavor.INPUT_STREAM.PCL;
        } else if (flavor.equalsIgnoreCase("DocFlavor.URL")) {
            d = DocFlavor.URL.PCL;
        }

        return d;
    }

    private static Date getLocalTimestamp(ConfigMap configMap, String group) {
        String timestamp = getConfigMapValue(configMap, LOCAL_TIMESTAMP_PREFIX + group);
        if (timestamp == null) {
            return null;
        }

        try {
            return new SimpleDateFormat(DATE_TIME_FORMAT).parse(timestamp);
        } catch (Exception e) {
            LOG.warn("Unable to parse time string '{}' using format {}", timestamp, DATE_TIME_FORMAT, e);
        }

        return null;
    }

    private boolean existsRemote(ShareFileClient fileClient) {
        try {
            return Boolean.TRUE
                    .equals(fileClient.existsWithResponse(endpoint.getMetadataTimeout(), Context.NONE).getValue());
        } catch (ShareStorageException ex) {
             
            if (ex.getStatusCode() == HTTP_NOT_FOUND) {
                return false;
            }
            throw ex;
        }
    }

    protected void doStop() throws Exception {
        super.doStop();

        LOG.debug("Stopping Kubernetes HPA Consumer");
        if (executor != null) {
            KubernetesHelper.close(hpasWatcher, hpasWatcher::getWatch);

            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownNow(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    private ScrollResponse<TDocument> scrollSearch() {
        ScrollResponse<TDocument> scrollResponse;
        try {
            ScrollRequest searchScrollRequest = new ScrollRequest.Builder()
                    .scroll(Time.of(b -> b.time(String.format("%sms", scrollKeepAliveMs))))
                    .scrollId(scrollId)
                    .build();

            scrollResponse = esClient.scroll(searchScrollRequest, documentClass);
            requestCount++;
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
        return scrollResponse;
    }

    public V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
        if (key == null || remappingFunction == null) {
            throw new NullPointerException();
        }
        for (;;) {
            SoftReference<V> ref = delegate.get(key);
            V oldValue = ref == null ? null : ref.get();
            V newValue = remappingFunction.apply(key, oldValue);
            if (newValue == null) {
                 
                if (ref != null && !delegate.remove(key, ref)) {
                     
                    continue;
                }
            } else if (ref == null) {
                if (delegate.putIfAbsent(key, new SoftReference<>(newValue)) != null) {
                     
                    continue;
                }
            } else if (!delegate.replace(key, ref, new SoftReference<>(newValue))) {
                 
                continue;
            }
            return newValue;
        }
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "brokerURL": ((ActiveMQComponent) component).setBrokerURL((java.lang.String) value); return true;
            case "clientId": getOrCreateConfiguration((ActiveMQComponent) component).setClientId((java.lang.String) value); return true;
            case "connectionFactory": getOrCreateConfiguration((ActiveMQComponent) component).setConnectionFactory((jakarta.jms.ConnectionFactory) value); return true;
            case "disableReplyTo": getOrCreateConfiguration((ActiveMQComponent) component).setDisableReplyTo((boolean) value); return true;
            case "durableSubscriptionName": getOrCreateConfiguration((ActiveMQComponent) component).setDurableSubscriptionName((java.lang.String) value); return true;
            case "embedded": ((ActiveMQComponent) component).setEmbedded((boolean) value); return true;
            case "jmsMessageType": getOrCreateConfiguration((ActiveMQComponent) component).setJmsMessageType((org.apache.camel.component.jms.JmsMessageType) value); return true;
            case "replyTo": getOrCreateConfiguration((ActiveMQComponent) component).setReplyTo((java.lang.String) value); return true;
            case "testConnectionOnStartup": getOrCreateConfiguration((ActiveMQComponent) component).setTestConnectionOnStartup((boolean) value); return true;
            case "usePooledConnection": ((ActiveMQComponent) component).setUsePooledConnection((boolean) value); return true;
            case "useSingleConnection": ((ActiveMQComponent) component).setUseSingleConnection((boolean) value); return true;
            case "acknowledgementModeName": getOrCreateConfiguration((ActiveMQComponent) component).setAcknowledgementModeName((java.lang.String) value); return true;
            case "artemisConsumerPriority": getOrCreateConfiguration((ActiveMQComponent) component).setArtemisConsumerPriority((int) value); return true;
            case "asyncConsumer": getOrCreateConfiguration((ActiveMQComponent) component).setAsyncConsumer((boolean) value); return true;
            case "autoStartup": getOrCreateConfiguration((ActiveMQComponent) component).setAutoStartup((boolean) value); return true;
            case "cacheLevel": getOrCreateConfiguration((ActiveMQComponent) component).setCacheLevel((int) value); return true;
            case "cacheLevelName": getOrCreateConfiguration((ActiveMQComponent) component).setCacheLevelName((java.lang.String) value); return true;
            case "concurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setConcurrentConsumers((int) value); return true;
            case "maxConcurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setMaxConcurrentConsumers((int) value); return true;
            case "replyToDeliveryPersistent": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToDeliveryPersistent((boolean) value); return true;
            case "selector": getOrCreateConfiguration((ActiveMQComponent) component).setSelector((java.lang.String) value); return true;
            case "subscriptionDurable": getOrCreateConfiguration((ActiveMQComponent) component).setSubscriptionDurable((boolean) value); return true;
            case "subscriptionName": getOrCreateConfiguration((ActiveMQComponent) component).setSubscriptionName((java.lang.String) value); return true;
            case "subscriptionShared": getOrCreateConfiguration((ActiveMQComponent) component).setSubscriptionShared((boolean) value); return true;
            case "acceptMessagesWhileStopping": getOrCreateConfiguration((ActiveMQComponent) component).setAcceptMessagesWhileStopping((boolean) value); return true;
            case "allowReplyManagerQuickStop": getOrCreateConfiguration((ActiveMQComponent) component).setAllowReplyManagerQuickStop((boolean) value); return true;
            case "consumerType": getOrCreateConfiguration((ActiveMQComponent) component).setConsumerType((org.apache.camel.component.jms.ConsumerType) value); return true;
            case "defaultTaskExecutorType": getOrCreateConfiguration((ActiveMQComponent) component).setDefaultTaskExecutorType((org.apache.camel.component.jms.DefaultTaskExecutorType) value); return true;
            case "eagerLoadingOfProperties": getOrCreateConfiguration((ActiveMQComponent) component).setEagerLoadingOfProperties((boolean) value); return true;
            case "eagerPoisonBody": getOrCreateConfiguration((ActiveMQComponent) component).setEagerPoisonBody((java.lang.String) value); return true;
            case "exposeListenerSession": getOrCreateConfiguration((ActiveMQComponent) component).setExposeListenerSession((boolean) value); return true;
            case "replyToConsumerType": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToConsumerType((org.apache.camel.component.jms.ConsumerType) value); return true;
            case "replyToSameDestinationAllowed": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToSameDestinationAllowed((boolean) value); return true;
            case "taskExecutor": getOrCreateConfiguration((ActiveMQComponent) component).setTaskExecutor((org.springframework.core.task.TaskExecutor) value); return true;
            case "deliveryDelay": getOrCreateConfiguration((ActiveMQComponent) component).setDeliveryDelay((long) value); return true;
            case "deliveryMode": getOrCreateConfiguration((ActiveMQComponent) component).setDeliveryMode((java.lang.Integer) value); return true;
            case "deliveryPersistent": getOrCreateConfiguration((ActiveMQComponent) component).setDeliveryPersistent((boolean) value); return true;
            case "explicitQosEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setExplicitQosEnabled((java.lang.Boolean) value); return true;
            case "formatDateHeadersToIso8601": getOrCreateConfiguration((ActiveMQComponent) component).setFormatDateHeadersToIso8601((boolean) value); return true;
            case "lazyStartProducer": ((ActiveMQComponent) component).setLazyStartProducer((boolean) value); return true;
            case "preserveMessageQos": getOrCreateConfiguration((ActiveMQComponent) component).setPreserveMessageQos((boolean) value); return true;
            case "priority": getOrCreateConfiguration((ActiveMQComponent) component).setPriority((int) value); return true;
            case "replyToConcurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToConcurrentConsumers((int) value); return true;
            case "replyToMaxConcurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToMaxConcurrentConsumers((int) value); return true;
            case "replyToOnTimeoutMaxConcurrentConsumers": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToOnTimeoutMaxConcurrentConsumers((int) value); return true;
            case "replyToOverride": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToOverride((java.lang.String) value); return true;
            case "replyToType": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToType((org.apache.camel.component.jms.ReplyToType) value); return true;
            case "requestTimeout": getOrCreateConfiguration((ActiveMQComponent) component).setRequestTimeout((long) value); return true;
            case "timeToLive": getOrCreateConfiguration((ActiveMQComponent) component).setTimeToLive((long) value); return true;
            case "allowAdditionalHeaders": getOrCreateConfiguration((ActiveMQComponent) component).setAllowAdditionalHeaders((java.lang.String) value); return true;
            case "allowNullBody": getOrCreateConfiguration((ActiveMQComponent) component).setAllowNullBody((boolean) value); return true;
            case "alwaysCopyMessage": getOrCreateConfiguration((ActiveMQComponent) component).setAlwaysCopyMessage((boolean) value); return true;
            case "correlationProperty": getOrCreateConfiguration((ActiveMQComponent) component).setCorrelationProperty((java.lang.String) value); return true;
            case "disableTimeToLive": getOrCreateConfiguration((ActiveMQComponent) component).setDisableTimeToLive((boolean) value); return true;
            case "forceSendOriginalMessage": getOrCreateConfiguration((ActiveMQComponent) component).setForceSendOriginalMessage((boolean) value); return true;
            case "includeSentJMSMessageID": getOrCreateConfiguration((ActiveMQComponent) component).setIncludeSentJMSMessageID((boolean) value); return true;
            case "replyCorrelationProperty": getOrCreateConfiguration((ActiveMQComponent) component).setReplyCorrelationProperty((java.lang.String) value); return true;
            case "replyToCacheLevelName": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToCacheLevelName((java.lang.String) value); return true;
            case "replyToDestinationSelectorName": getOrCreateConfiguration((ActiveMQComponent) component).setReplyToDestinationSelectorName((java.lang.String) value); return true;
            case "streamMessageTypeEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setStreamMessageTypeEnabled((boolean) value); return true;
            case "allowAutoWiredConnectionFactory": ((ActiveMQComponent) component).setAllowAutoWiredConnectionFactory((boolean) value); return true;
            case "allowAutoWiredDestinationResolver": ((ActiveMQComponent) component).setAllowAutoWiredDestinationResolver((boolean) value); return true;
            case "allowSerializedHeaders": getOrCreateConfiguration((ActiveMQComponent) component).setAllowSerializedHeaders((boolean) value); return true;
            case "artemisStreamingEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setArtemisStreamingEnabled((boolean) value); return true;
            case "asyncStartListener": getOrCreateConfiguration((ActiveMQComponent) component).setAsyncStartListener((boolean) value); return true;
            case "asyncStopListener": getOrCreateConfiguration((ActiveMQComponent) component).setAsyncStopListener((boolean) value); return true;
            case "autowiredEnabled": ((ActiveMQComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "browseLimit": getOrCreateConfiguration((ActiveMQComponent) component).setBrowseLimit((int) value); return true;
            case "configuration": ((ActiveMQComponent) component).setConfiguration((org.apache.camel.component.jms.JmsConfiguration) value); return true;
            case "destinationResolver": getOrCreateConfiguration((ActiveMQComponent) component).setDestinationResolver((org.springframework.jms.support.destination.DestinationResolver) value); return true;
            case "errorHandler": getOrCreateConfiguration((ActiveMQComponent) component).setErrorHandler((org.springframework.util.ErrorHandler) value); return true;
            case "exceptionListener": getOrCreateConfiguration((ActiveMQComponent) component).setExceptionListener((jakarta.jms.ExceptionListener) value); return true;
            case "idleConsumerLimit": getOrCreateConfiguration((ActiveMQComponent) component).setIdleConsumerLimit((int) value); return true;
            case "idleReceivesPerTaskLimit": getOrCreateConfiguration((ActiveMQComponent) component).setIdleReceivesPerTaskLimit((int) value); return true;
            case "idleTaskExecutionLimit": getOrCreateConfiguration((ActiveMQComponent) component).setIdleTaskExecutionLimit((int) value); return true;
            case "includeAllJMSXProperties": getOrCreateConfiguration((ActiveMQComponent) component).setIncludeAllJMSXProperties((boolean) value); return true;
            case "includeCorrelationIDAsBytes": ((ActiveMQComponent) component).setIncludeCorrelationIDAsBytes((boolean) value); return true;
            case "jmsKeyFormatStrategy": getOrCreateConfiguration((ActiveMQComponent) component).setJmsKeyFormatStrategy((org.apache.camel.component.jms.JmsKeyFormatStrategy) value); return true;
            case "mapJmsMessage": getOrCreateConfiguration((ActiveMQComponent) component).setMapJmsMessage((boolean) value); return true;
            case "maxMessagesPerTask": getOrCreateConfiguration((ActiveMQComponent) component).setMaxMessagesPerTask((int) value); return true;
            case "messageConverter": getOrCreateConfiguration((ActiveMQComponent) component).setMessageConverter((org.springframework.jms.support.converter.MessageConverter) value); return true;
            case "messageCreatedStrategy": getOrCreateConfiguration((ActiveMQComponent) component).setMessageCreatedStrategy((org.apache.camel.component.jms.MessageCreatedStrategy) value); return true;
            case "messageIdEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setMessageIdEnabled((boolean) value); return true;
            case "messageListenerContainerFactory": getOrCreateConfiguration((ActiveMQComponent) component).setMessageListenerContainerFactory((org.apache.camel.component.jms.MessageListenerContainerFactory) value); return true;
            case "messageTimestampEnabled": getOrCreateConfiguration((ActiveMQComponent) component).setMessageTimestampEnabled((boolean) value); return true;
            case "pubSubNoLocal": getOrCreateConfiguration((ActiveMQComponent) component).setPubSubNoLocal((boolean) value); return true;
            case "queueBrowseStrategy": ((ActiveMQComponent) component).setQueueBrowseStrategy((org.apache.camel.component.jms.QueueBrowseStrategy) value); return true;
            case "receiveTimeout": getOrCreateConfiguration((ActiveMQComponent) component).setReceiveTimeout((long) value); return true;
            case "recoveryInterval": getOrCreateConfiguration((ActiveMQComponent) component).setRecoveryInterval((long) value); return true;
            case "requestTimeoutCheckerInterval": getOrCreateConfiguration((ActiveMQComponent) component).setRequestTimeoutCheckerInterval((long) value); return true;
            case "serviceLocationEnabled": ((ActiveMQComponent) component).setServiceLocationEnabled((boolean) value); return true;
            case "synchronous": getOrCreateConfiguration((ActiveMQComponent) component).setSynchronous((boolean) value); return true;
            case "temporaryQueueResolver": getOrCreateConfiguration((ActiveMQComponent) component).setTemporaryQueueResolver((org.apache.camel.component.jms.TemporaryQueueResolver) value); return true;
            case "transferException": getOrCreateConfiguration((ActiveMQComponent) component).setTransferException((boolean) value); return true;
            case "transferExchange": getOrCreateConfiguration((ActiveMQComponent) component).setTransferExchange((boolean) value); return true;
            case "trustAllPackages": ((ActiveMQComponent) component).setTrustAllPackages((boolean) value); return true;
            case "useMessageIDAsCorrelationID": getOrCreateConfiguration((ActiveMQComponent) component).setUseMessageIDAsCorrelationID((boolean) value); return true;
            case "waitForProvisionCorrelationToBeUpdatedCounter": getOrCreateConfiguration((ActiveMQComponent) component).setWaitForProvisionCorrelationToBeUpdatedCounter((int) value); return true;
            case "waitForProvisionCorrelationToBeUpdatedThreadSleepingTime": getOrCreateConfiguration((ActiveMQComponent) component).setWaitForProvisionCorrelationToBeUpdatedThreadSleepingTime((long) value); return true;
            case "waitForTemporaryReplyToToBeUpdatedCounter": getOrCreateConfiguration((ActiveMQComponent) component).setWaitForTemporaryReplyToToBeUpdatedCounter((int) value); return true;
            case "waitForTemporaryReplyToToBeUpdatedThreadSleepingTime": getOrCreateConfiguration((ActiveMQComponent) component).setWaitForTemporaryReplyToToBeUpdatedThreadSleepingTime((long) value); return true;
            case "headerFilterStrategy": ((ActiveMQComponent) component).setHeaderFilterStrategy((org.apache.camel.spi.HeaderFilterStrategy) value); return true;
            case "errorHandlerLoggingLevel": getOrCreateConfiguration((ActiveMQComponent) component).setErrorHandlerLoggingLevel((org.apache.camel.LoggingLevel) value); return true;
            case "errorHandlerLogStackTrace": getOrCreateConfiguration((ActiveMQComponent) component).setErrorHandlerLogStackTrace((boolean) value); return true;
            case "password": getOrCreateConfiguration((ActiveMQComponent) component).setPassword((java.lang.String) value); return true;
            case "username": getOrCreateConfiguration((ActiveMQComponent) component).setUsername((java.lang.String) value); return true;
            case "transacted": getOrCreateConfiguration((ActiveMQComponent) component).setTransacted((boolean) value); return true;
            case "transactedInOut": getOrCreateConfiguration((ActiveMQComponent) component).setTransactedInOut((boolean) value); return true;
            case "lazyCreateTransactionManager": getOrCreateConfiguration((ActiveMQComponent) component).setLazyCreateTransactionManager((boolean) value); return true;
            case "transactionManager": getOrCreateConfiguration((ActiveMQComponent) component).setTransactionManager((org.springframework.transaction.PlatformTransactionManager) value); return true;
            case "transactionName": getOrCreateConfiguration((ActiveMQComponent) component).setTransactionName((java.lang.String) value); return true;
            case "transactionTimeout": getOrCreateConfiguration((ActiveMQComponent) component).setTransactionTimeout((int) value); return true;
            default: return false;
            }
        }

    public static Exchange toExchange(
            Endpoint endpoint, SessionID sessionID, Message message, QuickfixjEventCategory eventCategory,
            ExchangePattern exchangePattern) {
        Exchange exchange = endpoint.createExchange(exchangePattern);

        org.apache.camel.Message camelMessage = exchange.getIn();
        camelMessage.setHeader(EVENT_CATEGORY_KEY, eventCategory);
        camelMessage.setHeader(SESSION_ID_KEY, sessionID);

        if (message != null) {
            try {
                camelMessage.setHeader(MESSAGE_TYPE_KEY, message.getHeader().getString(MsgType.FIELD));
            } catch (FieldNotFound e) {
                LOG.warn("Message type field not found in QFJ message: {}, continuing...", message);
            }
        }
        camelMessage.setBody(message);

        return exchange;
    }

                public void artifactDownloaded(RepositoryEvent event) {
                    if (event.getArtifact() != null) {
                        Artifact a = event.getArtifact();

                        ArtifactRepository ar = event.getRepository();
                        String url = ar instanceof RemoteRepository ? ((RemoteRepository) ar).getUrl() : null;
                        String id = ar != null ? ar.getId() : null;
                        long elapsed = watch.takenAndRestart();
                        String version = a.isSnapshot() ? a.getBaseVersion() : a.getVersion();
                        remoteArtifactDownloadListener.artifactDownloaded(a.getGroupId(), a.getArtifactId(), version,
                                id, url, elapsed);
                    }
                }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.io.InputStream.class, org.apache.camel.component.file.GenericFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.file.GenericFileConverter.genericFileToInputStream((org.apache.camel.component.file.GenericFile) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.io.Reader.class, org.apache.camel.component.file.GenericFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.file.GenericFileConverter.genericFileToReader((org.apache.camel.component.file.GenericFile) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.io.Serializable.class, org.apache.camel.component.file.GenericFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.file.GenericFileConverter.genericFileToSerializable((org.apache.camel.component.file.GenericFile) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, org.apache.camel.component.file.GenericFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.file.GenericFileConverter.genericFileToString((org.apache.camel.component.file.GenericFile) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    private void configureTimeoutExecutorService(ResilienceProcessor processor, Resilience4jConfigurationCommon config) {
        if (!parseBoolean(config.getTimeoutEnabled(), false)) {
            return;
        }

        if (config.getTimeoutExecutorService() != null) {
            String ref = config.getTimeoutExecutorService();
            boolean shutdownThreadPool = false;
            ExecutorService executorService = lookupByNameAndType(ref, ExecutorService.class);
            if (executorService == null) {
                executorService = lookupExecutorServiceRef("CircuitBreaker", definition, ref);
                shutdownThreadPool = true;
            }
            processor.setExecutorService(executorService);
            processor.setShutdownExecutorService(shutdownThreadPool);
        }
    }

    protected void decode(
            ChannelHandlerContext ctx, AddressedEnvelope<Object, InetSocketAddress> msg,
            List<Object> out)
            throws Exception {
        if (msg.content() instanceof ByteBuf) {
            ByteBuf payload = (ByteBuf) msg.content();
            Object result = delegateDecoder.decode(ctx, payload);
            AddressedEnvelope<Object, InetSocketAddress> addressEvelop
                    = new DefaultAddressedEnvelope<>(result, msg.recipient(), msg.sender());
            out.add(addressEvelop);
        } else {
            LOG.debug("Ignoring message content as it is not an io.netty.buffer.ByteBuf instance.");
        }
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        InfluxDb2Endpoint endpoint = new InfluxDb2Endpoint(uri, this);
        endpoint.setConnectionBean(remaining);
        InfluxDBClient target = influxDBClient;
        if (target == null) {
             
            target = CamelContextHelper.mandatoryLookup(getCamelContext(), remaining, InfluxDBClient.class);
        }
        endpoint.setInfluxDBClient(target);
        setProperties(endpoint, parameters);
        return endpoint;
    }

        DateTimeFormatter getDateFormat() {
            DateTimeFormatter result;
            if (locale != null) {
                result = DateTimeFormatter.ofPattern(pattern, locale);
            } else {
                result = DateTimeFormatter.ofPattern(pattern);
            }
            return result;
        }

    public String getLabel() {
        if (endpointUriToString == null) {
            String value = null;
            try {
                value = getEndpointUri();
            } catch (RuntimeException e) {
                 
            }
             
            endpointUriToString = URISupport.sanitizeUri(value);
        }

        String uri = endpointUriToString;
        return "to[" + uri + "]";
    }

    public Processor wrap(Route route, Processor processor) {
        JtaTransactionErrorHandler answer;
         
         
         
         
         
         
         
         

         
        RouteDefinition routeDefinition = (RouteDefinition) route.getRoute();
        ErrorHandlerFactory builder = routeDefinition.getErrorHandlerFactory();

         
        if (builder instanceof RefErrorHandlerDefinition) {
             
            RefErrorHandlerDefinition builderRef = (RefErrorHandlerDefinition) builder;
            String ref = builderRef.getRef();
             
             
             
            if (ErrorHandlerHelper.isErrorHandlerFactoryConfigured(ref)) {
                LOG.debug("Looking up ErrorHandlerBuilder with ref: {}", ref);
                builder = ErrorHandlerHelper.lookupErrorHandlerFactory(route, ref, true);
            }
        }

        JtaTransactionErrorHandlerDefinition txBuilder;
        if (builder != null && builder.supportTransacted()) {
            if (!(builder instanceof JtaTransactionErrorHandlerDefinition)) {
                throw new RuntimeCamelException(
                        "The given transactional error handler builder '" + builder
                                                + "' is not of type '" + JtaTransactionErrorHandlerDefinition.class.getName()
                                                + "' which is required in this environment!");
            }
            LOG.debug("The ErrorHandlerBuilder configured is a JtaTransactionErrorHandlerDefinition: {}", builder);
            txBuilder = (JtaTransactionErrorHandlerDefinition) builder.cloneBuilder();
        } else {
            LOG.debug(
                    "No or no transactional ErrorHandlerBuilder configured, will use default JtaTransactionErrorHandlerDefinition settings");
            txBuilder = new JtaTransactionErrorHandlerDefinition();
        }

        txBuilder.setTransactedPolicy(this);

         
        if (builder != null) {
            route.addErrorHandlerFactoryReference(builder, txBuilder);
        }

        answer = createTransactionErrorHandler(route, processor, txBuilder);

         
        route.setErrorHandlerFactory(txBuilder);

         
        return answer;
    }

    public void abortJob(String jobId, Map<String, List<String>> headers, final JobInfoResponseCallback callback) {
        final JobInfo request = new JobInfo();
        request.setState(JobStateEnum.ABORTED);

        final Request post = getRequest(HttpMethod.POST, jobUrl(jobId), headers);
        try {
            marshalRequest(objectFactory.createJobInfo(request), post, APPLICATION_XML_UTF8);
        } catch (SalesforceException e) {
            callback.onResponse(null, Collections.emptyMap(), e);
            return;
        }

         
        doHttpRequest(post, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                JobInfo value = null;
                try {
                    value = unmarshalResponse(response, post, JobInfo.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(value, headers, ex);
            }
        });
    }

    private void setAdditionalConfiguration(RestConfiguration config, String prefix, PropertyBindingSupport.Builder builder) {
        if (config.getDataFormatProperties() != null && !config.getDataFormatProperties().isEmpty()) {
             
             
            Map<String, Object> copy = new HashMap<>();

             
             
             
            for (Map.Entry<String, Object> entry : config.getDataFormatProperties().entrySet()) {
                String key = entry.getKey();
                String copyKey;
                boolean known = isKeyKnownPrefix(key);
                if (known) {
                     
                    copyKey = key.substring(prefix.length());
                } else {
                     
                    copyKey = key;
                }
                if (!known || key.startsWith(prefix)) {
                    copy.put(copyKey, entry.getValue());
                }
            }

            builder.withProperties(copy);
        }
    }

    public void failedExchange(Exchange exchange) {
         
         
         
         
        UnitOfWork uow = exchange.getUnitOfWork();
        if (uow != null) {
            int level = uow.routeStackLevel(includeRouteTemplates, includeKamelets);
            if (level <= 1) {
                super.failedExchange(exchange);
                if (exchange.getFromEndpoint() != null && exchange.getFromEndpoint().isRemote()) {
                    remoteExchangesTotal.increment();
                    remoteExchangesFailed.increment();
                    remoteExchangesInflight.decrement();
                }
            }
        } else {
            super.failedExchange(exchange);
            if (exchange.getFromEndpoint() != null && exchange.getFromEndpoint().isRemote()) {
                remoteExchangesTotal.increment();
                remoteExchangesFailed.increment();
                remoteExchangesInflight.decrement();
            }
        }
    }

    public void onPutAllAsync(Message message) {
        final BasicCache<Object, Object> cache = getCache(message);
        final Map<?, ?> map = message.getHeader(InfinispanConstants.MAP, Map.class);
        final CompletableFuture<Void> result;

        if (hasLifespan(message)) {
            long lifespan = message.getHeader(InfinispanConstants.LIFESPAN_TIME, long.class);
            TimeUnit timeUnit = message.getHeader(InfinispanConstants.LIFESPAN_TIME_UNIT, TimeUnit.class);

            if (hasMaxIdleTime(message)) {
                long maxIdle = message.getHeader(InfinispanConstants.MAX_IDLE_TIME, long.class);
                TimeUnit maxIdleTimeUnit = message.getHeader(InfinispanConstants.MAX_IDLE_TIME_UNIT, TimeUnit.class);

                result = cache.putAllAsync(map, lifespan, timeUnit, maxIdle, maxIdleTimeUnit);
            } else {
                result = cache.putAllAsync(map, lifespan, timeUnit);
            }
        } else {
            result = cache.putAllAsync(map);
        }

        setResult(message, result);
    }

        public CamelPostProcessorHelper getPostProcessorHelper() {
             
            if (camelPostProcessorHelper == null) {
                camelPostProcessorHelper = new CamelPostProcessorHelper() {

                    @Override
                    public CamelContext getCamelContext() {
                         
                         
                         
                         
                        return delegate.getOrLookupCamelContext();
                    }

                    @Override
                    protected RuntimeException createProxyInstantiationRuntimeException(
                            Class<?> type, Endpoint endpoint, Exception e) {
                        return new BeanInstantiationException(
                                type, "Could not instantiate proxy of type " + type.getName() + " on endpoint " + endpoint, e);
                    }

                    @Override
                    protected boolean isSingleton(Object bean, String beanName) {
                         
                         
                        if (applicationContext == null || beanName == null) {
                            return super.isSingleton(bean, beanName);
                        } else {
                            return applicationContext.isSingleton(beanName);
                        }
                    }

                    @Override
                    protected void startService(Service service, CamelContext context, Object bean, String beanName)
                            throws Exception {
                        if (isSingleton(bean, beanName)) {
                            getCamelContext().addService(service);
                        } else {
                             
                            ServiceHelper.startService(service);
                            if (prototypeBeans.add(beanName)) {
                                 
                                CamelBeanPostProcessor.LOG
                                        .warn("The bean with id [{}] is prototype scoped and cannot stop the injected "
                                              + " service when bean is destroyed: {}. You may want to stop the service "
                                              + "manually from the bean.", beanName, service);
                            }
                        }
                    }
                };
            }
            return camelPostProcessorHelper;
        }

    public static boolean isBoundaryCloseDelimiter(final CharArrayBuffer buffer, ParserCursor cursor, String boundary) {
        ObjectHelper.notNull(buffer, "Buffer");
        ObjectHelper.notNull(boundary, "Boundary");

        String boundaryCloseDelimiter = "--" + boundary + "--";  
         
         
         

        if (cursor == null) {
            cursor = new ParserCursor(0, boundaryCloseDelimiter.length());
        }

        int indexFrom = cursor.getPos();
        int indexTo = cursor.getUpperBound();

        if ((indexFrom + boundaryCloseDelimiter.length()) > indexTo) {
            return false;
        }

        for (int i = indexFrom; i < indexTo; ++i) {
            if (buffer.charAt(i) != boundaryCloseDelimiter.charAt(i)) {
                return false;
            }
        }

        return true;
    }

    protected void configureParameters(Query query) {
        int maxResults = getEndpoint().getMaximumResults();
        if (maxResults > 0) {
            query.setMaxResults(maxResults);
        }
         
        if (parameters != null) {
            for (Entry<String, Object> entry : parameters.entrySet()) {
                query.setParameter(entry.getKey(), entry.getValue());
            }
        }
    }

    private List<JsonObject> enrichSourceCode(String routeId, String location, int lines) {
        Route route = getCamelContext().getRoute(routeId);
        if (route == null) {
            return null;
        }
        Resource resource = route.getSourceResource();
        if (resource == null) {
            return null;
        }

        List<JsonObject> code = new ArrayList<>();

        location = StringHelper.afterLast(location, ":");
        int line = 0;
        try {
            if (location != null) {
                line = Integer.parseInt(location);
            }
            LineNumberReader reader = new LineNumberReader(resource.getReader());
            for (int i = 1; i <= line + lines; i++) {
                String t = reader.readLine();
                if (t != null) {
                    int low = line - lines + 2;  
                    int high = line + lines + 1 + 2;
                    if (i >= low && i <= high) {
                        JsonObject c = new JsonObject();
                        c.put("line", i);
                        if (line == i) {
                            c.put("match", true);
                        }
                        c.put("code", Jsoner.escape(t));
                        code.add(c);
                    }
                }
            }
            IOHelper.close(reader);
        } catch (Exception e) {
             
        }

        return code;
    }

    public Transformer resolve(TransformerKey key, CamelContext context) {
        String name = key.toString();
        TransformerModel model = catalog.transformerModel(name);
        if (model != null) {
            downloadLoader(model.getGroupId(), model.getArtifactId(), model.getVersion());
        }

        Transformer answer;
        boolean accept = accept(name);
        if (accept) {
            answer = super.resolve(key, context);
        } else {
            answer = new StubTransformer();
        }

        if (answer == null) {
            List<String> suggestion = SuggestSimilarHelper.didYouMean(catalog.findTransformerNames(), name);
            if (suggestion != null && !suggestion.isEmpty()) {
                String s = String.join(", ", suggestion);
                throw new IllegalArgumentException("Cannot find transformer with name: " + name + ". Did you mean: " + s);
            }
        }
        return answer;
    }

    protected void decode(ChannelHandlerContext ctx, AddressedEnvelope<Object, InetSocketAddress> msg, List<Object> out)
            throws Exception {
        if (msg.content() instanceof ByteBuf) {
            delegateDecoder.decode(ctx, (ByteBuf) msg.content(), out);
            byte[] content = (byte[]) out.remove(out.size() - 1);
            AddressedEnvelope<Object, InetSocketAddress> addressedEnvelop
                    = new DefaultAddressedEnvelope<>(content, msg.recipient(), msg.sender());
            out.add(addressedEnvelop);
        } else {
            LOG.debug("Ignoring message content as it is not an io.netty.buffer.ByteBuf instance.");
        }
    }

    public Exchange add(CamelContext camelContext, String key, Exchange exchange) {
        if (optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(), key);
        Lock l = hazelcastInstance.getCPSubsystem().getLock(mapName);
        try {
            l.lock();
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(exchange, true, allowSerializedHeaders);
            DefaultExchangeHolder oldHolder = cache.put(key, newHolder);
            return unmarshallExchange(camelContext, oldHolder);
        } finally {
            LOG.trace("Added an Exchange with ID {} for key {} in a thread-safe manner.", exchange.getExchangeId(), key);
            l.unlock();
        }
    }

    public int forceDiscardingOfAllGroups() {

         
        boolean allow = camelContext.getStatus().isStarted() || camelContext.getStatus().isStopping();
        if (!allow) {
            LOG.warn("Cannot start force discarding of all groups because CamelContext({}) has not been started",
                    camelContext.getName());
            return 0;
        }

        LOG.trace("Starting force discarding of all groups task");

         
        Set<String> keys = aggregationRepository.getKeys();

        int total = 0;
        if (keys != null && !keys.isEmpty()) {
             
            lock.lock();
            total = keys.size();
            try {
                for (String key : keys) {
                    Exchange exchange = aggregationRepository.get(camelContext, key);
                    if (exchange != null) {
                        LOG.trace("Force discarded triggered for correlation key: {}", key);
                         
                        onCompletion(key, exchange, exchange, false, true);
                    }
                }
            } finally {
                lock.unlock();
            }
        }
        LOG.trace("Completed force discarding of all groups task");

        if (total > 0) {
            LOG.debug("Forcing discarding of all groups with {} exchanges", total);
        }
        return total;
    }

    protected void afterConfigureProperties() {
        switch (apiName) {
            case DRIVE_ABOUT:
                apiProxy = getClient().about();
                break;
            case DRIVE_CHANGES:
                apiProxy = getClient().changes();
                break;
            case DRIVE_CHANNELS:
                apiProxy = getClient().channels();
                break;
            case DRIVE_COMMENTS:
                apiProxy = getClient().comments();
                break;
            case DRIVE_DRIVES:
                apiProxy = getClient().drives();
                break;
            case DRIVE_FILES:
                apiProxy = getClient().files();
                break;
            case DRIVE_PERMISSIONS:
                apiProxy = getClient().permissions();
                break;
            case DRIVE_REPLIES:
                apiProxy = getClient().replies();
                break;
            case DRIVE_REVISIONS:
                apiProxy = getClient().revisions();
                break;
            case DRIVE_TEAMDRIVES:
                apiProxy = getClient().teamdrives();
                break;
            default:
                throw new IllegalArgumentException("Invalid API name " + apiName);
        }
    }

    public DaprOperationResponse handle(Exchange exchange) {
        WorkflowOperation workflowOperation = configurationOptionsProxy.getWorkflowOperation(exchange);
        DaprWorkflowClient client = endpoint.getWorkflowClient();

        switch (workflowOperation) {
            case scheduleNew:
                return scheduleNewWorkflow(exchange, client);
            case terminate:
                return terminateWorkflow(exchange, client);
            case purge:
                return purgeWorkflow(exchange, client);
            case suspend:
                return suspendWorkflow(exchange, client);
            case resume:
                return resumeWorkflow(exchange, client);
            case state:
                return getWorkflowState(exchange, client);
            case waitForInstanceStart:
                return waitForInstanceStart(exchange, client);
            case waitForInstanceCompletion:
                return waitForInstanceCompletion(exchange, client);
            case raiseEvent:
                return raiseEvent(exchange, client);
            default:
                throw new IllegalArgumentException("Unsupported workflow operation");
        }
    }

    static Map<String, List<String>> determineHeaders(final Exchange exchange) {
        final Message inboundMessage = exchange.getIn();

        final Map<String, Object> headers = inboundMessage.getHeaders();

        final Map<String, List<String>> answer = new HashMap<>();
        for (final String headerName : headers.keySet()) {
            final String headerNameLowercase = headerName.toLowerCase(Locale.US);
            if (headerNameLowercase.startsWith("sforce") || headerNameLowercase.startsWith("x-sfdc")) {
                final Object headerValue = inboundMessage.getHeader(headerName);

                if (headerValue instanceof String) {
                    answer.put(headerName, Collections.singletonList((String) headerValue));
                } else if (headerValue instanceof String[]) {
                    answer.put(headerName, Arrays.asList((String[]) headerValue));
                } else if (headerValue instanceof Collection) {
                    answer.put(headerName,
                            ((Collection<?>) headerValue).stream().map(String::valueOf).collect(Collectors.<String> toList()));
                } else {
                    throw new IllegalArgumentException(
                            "Given value for header `" + headerName + "`, is not String, String array or a Collection");
                }
            }
        }
        return answer;
    }

    protected void configureParameters(Query query) {
        int maxResults = getEndpoint().getMaximumResults();
        if (maxResults > 0) {
            query.setMaxResults(maxResults);
        }
         
        if (parameters != null) {
            for (Map.Entry<String, Object> entry : parameters.entrySet()) {
                query.setParameter(entry.getKey(), entry.getValue());
            }
        }
    }

    protected Boolean omitXmlDeclaration(Message message, Input input) {
        Boolean omitXmlDeclaration = message.getHeader(XmlSignatureConstants.HEADER_OMIT_XML_DECLARATION, Boolean.class);
        if (omitXmlDeclaration == null) {
            omitXmlDeclaration = input.omitXmlDeclaration();
        }
        if (omitXmlDeclaration == null) {
            omitXmlDeclaration = Boolean.FALSE;
        }
        return omitXmlDeclaration;
    }

    public static void parseXmlRouteSimpleExpressions(
            InputStream xml, String baseDir, String fullyQualifiedFileName,
            List<CamelSimpleExpressionDetails> simpleExpressions) {

         
         
        Document dom = getDocument(xml);
        if (dom != null) {
            List<Node> nodes = CamelXmlHelper.findAllLanguageExpressions(dom, "simple");
            for (Node node : nodes) {
                String simple = node.getTextContent();
                String lineNumber = (String) node.getUserData(XmlLineNumberParser.LINE_NUMBER);
                String lineNumberEnd = (String) node.getUserData(XmlLineNumberParser.LINE_NUMBER_END);

                String fileName = getFileName(baseDir, fullyQualifiedFileName);

                CamelSimpleExpressionDetails detail = new CamelSimpleExpressionDetails();
                detail.setFileName(fileName);
                detail.setLineNumber(lineNumber);
                detail.setLineNumberEnd(lineNumberEnd);
                detail.setSimple(simple);

                String column = (String) node.getUserData(XmlLineNumberParser.COLUMN_NUMBER);
                if (column != null) {
                    detail.setLinePosition(Integer.parseInt(column));
                }

                 
                boolean asPredicate = isSimplePredicate(node);
                detail.setPredicate(asPredicate);
                detail.setExpression(!asPredicate);

                simpleExpressions.add(detail);
            }
        }
    }

    public Double getDouble(final int index) {
        Object returnable = this.get(index);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).doubleValue();
    }

    private Breakpoint getSingleStepBreakpoint(Exchange exchange) {
        Breakpoint answer = singleSteps.get(exchange.getExchangeId());
        if (answer == null) {
             
            String id = exchange.getProperty(ExchangePropertyKey.CORRELATION_ID, String.class);
            if (id != null) {
                answer = singleSteps.get(id);
            }
        }
        return answer;
    }

    private TagImageCmd executeTagImageRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Tag Image Request");

        String imageId = DockerHelper.getProperty(DockerConstants.DOCKER_IMAGE_ID, configuration, message, String.class);

        String repository = DockerHelper.getProperty(DockerConstants.DOCKER_REPOSITORY, configuration, message, String.class);

        String tag = DockerHelper.getProperty(DockerConstants.DOCKER_TAG, configuration, message, String.class);

        if (imageId == null || repository == null || tag == null) {
            throw new IllegalArgumentException("ImageId, repository and tag must be specified");
        }

        TagImageCmd tagImageCmd = client.tagImageCmd(imageId, repository, tag);

        Boolean force = DockerHelper.getProperty(DockerConstants.DOCKER_FORCE, configuration, message, Boolean.class);

        if (force != null) {
            tagImageCmd.withForce(force);
        }

        return tagImageCmd;

    }

    public Optional<CamelClusterMember> getLeader() {
        if (this.cache == null) {
            return Optional.empty();
        }

        String id = cache.get(InfinispanClusterService.LEADER_KEY);
        if (id == null) {
            return Optional.empty();
        }

        return Optional.of(new ClusterMember(id));
    }

    protected void doStart() throws Exception {
         
         
        boolean startScheduler = isStartScheduler();
        setStartScheduler(false);
        try {
            super.doStart();
            if (endpoint.isAutoCreate() && hasStartingDirectory()) {
                String dir = endpoint.getConfiguration().getDirectory();
                LOG.debug("Auto creating directory: {}", dir);
                try {
                    connectIfNecessary();
                    operations.buildDirectory(dir, true);
                } catch (GenericFileOperationFailedException e) {
                     
                    LOG.warn(
                            "Error auto creating directory: " + dir + " due " + e.getMessage() + ". This exception is ignored.",
                            e);
                }
            }
        } finally {
            if (startScheduler) {
                setStartScheduler(true);
                startScheduler();
            }
        }
    }

    private LanguageValidationResult doValidateSimple(ClassLoader classLoader, String simple, boolean predicate) {
        if (classLoader == null) {
            classLoader = getClass().getClassLoader();
        }

         
         
         
         
        String resolved = simple.replaceAll("\\{\\{(.+)\\}\\}", "~^$1^~");

        LanguageValidationResult answer = new LanguageValidationResult(simple);

        Object context;
        Object instance = null;
        Class<?> clazz;

        try {
             
            clazz = classLoader.loadClass("org.apache.camel.impl.engine.SimpleCamelContext");
            context = clazz.getDeclaredConstructor(boolean.class).newInstance(false);
            clazz = classLoader.loadClass("org.apache.camel.language.simple.SimpleLanguage");
            instance = clazz.getDeclaredConstructor().newInstance();
            clazz = classLoader.loadClass("org.apache.camel.CamelContext");
            instance.getClass().getMethod("setCamelContext", clazz).invoke(instance, context);
        } catch (Exception e) {
            clazz = null;
            answer.setError(e.getMessage());
        }

        if (clazz != null) {
            Throwable cause = null;
            try {
                if (predicate) {
                    instance.getClass().getMethod("createPredicate", String.class).invoke(instance, resolved);
                } else {
                    instance.getClass().getMethod("createExpression", String.class).invoke(instance, resolved);
                }
            } catch (InvocationTargetException e) {
                cause = e.getTargetException();
            } catch (Exception e) {
                cause = e;
            }

            if (cause != null) {

                 
                String errMsg = cause.getMessage();
                errMsg = errMsg.replaceAll("\\~\\^(.+)\\^\\~", "{{$1}}");

                answer.setError(errMsg);

                 
                 
                if (cause.getClass().getName().equals("org.apache.camel.language.simple.types.SimpleIllegalSyntaxException")  
                        || cause.getClass().getName().equals("org.apache.camel.language.simple.types.SimpleParserException")) {  
                    try {
                         
                        Method method = cause.getClass().getMethod("getIndex");
                        Object result = method.invoke(cause);
                        if (result != null) {
                            int index = (int) result;
                            answer.setIndex(index);
                        }
                    } catch (Exception i) {
                         
                    }
                }

                 
                 
                if (cause.getClass().getName().equals("org.apache.camel.language.simple.types.SimpleIllegalSyntaxException")) {  
                    try {
                        Method method = cause.getClass().getMethod("getShortMessage");
                        Object result = method.invoke(cause);
                        if (result != null) {
                            String msg = (String) result;
                            answer.setShortError(msg);
                        }
                    } catch (Exception i) {
                         
                    }

                    if (answer.getShortError() == null) {
                         
                        String msg = answer.getError();
                         
                        int idx = msg.indexOf(" at location ");
                        if (idx > 0) {
                            msg = msg.substring(0, idx);
                            answer.setShortError(msg);
                        }
                    }
                }
            }
        }

        return answer;
    }

    public Sides assignSides(String sidesString) {
        Sides answer;

        if (sidesString == null) {
             
            answer = Sides.ONE_SIDED;
        } else if (sidesString.equalsIgnoreCase("one-sided")) {
            answer = Sides.ONE_SIDED;
        } else if (sidesString.equalsIgnoreCase("duplex")) {
            answer = Sides.DUPLEX;
        } else if (sidesString.equalsIgnoreCase("tumble")) {
            answer = Sides.TUMBLE;
        } else if (sidesString.equalsIgnoreCase("two-sided-short-edge")) {
            answer = Sides.TWO_SIDED_SHORT_EDGE;
        } else if (sidesString.equalsIgnoreCase("two-sided-long-edge")) {
            answer = Sides.TWO_SIDED_LONG_EDGE;
        } else {
            answer = Sides.ONE_SIDED;
        }

        return answer;
    }

    public Predicate createPredicate(String expression) {
        if (expression == null) {
            throw new IllegalArgumentException("expression must be specified");
        }
         
        String text = expression.replace("\n", "");
        text = text.trim();

        return compiledPredicates.computeIfAbsent(text, key -> {
            if (compilationSupport != null) {
                CSimpleExpression exp = compilationSupport.compilePredicate(getCamelContext(), expression);
                if (exp != null) {
                    exp.init(getCamelContext());
                    return exp;
                }
            }
            throw new CSimpleException("Cannot find compiled csimple language for predicate: " + expression, expression);
        });
    }

    public static boolean isBoundaryDelimiter(final CharArrayBuffer buffer, ParserCursor cursor, String boundary) {
        ObjectHelper.notNull(buffer, "Buffer");
        ObjectHelper.notNull(boundary, "Boundary");

        String boundaryDelimiter = "--" + boundary;  
         

        if (cursor == null) {
            cursor = new ParserCursor(0, boundaryDelimiter.length());
        }

        int indexFrom = cursor.getPos();
        int indexTo = cursor.getUpperBound();

        if ((indexFrom + boundaryDelimiter.length()) > indexTo) {
            return false;
        }

        for (int i = indexFrom; i < indexTo; ++i) {
            if (buffer.charAt(i) != boundaryDelimiter.charAt(i)) {
                return false;
            }
        }

        return true;
    }

    public XmlStreamReader(final InputStream is, final String httpContentType, final boolean lenient,
                           final String defaultEncoding) throws IOException, XmlStreamReaderException {
        if (defaultEncoding == null) {
            this.defaultEncoding = staticDefaultEncoding;
        } else {
            this.defaultEncoding = defaultEncoding;
        }
        try {
            doHttpStream(is, httpContentType, lenient);
        } catch (final XmlStreamReaderException ex) {
            if (!lenient) {
                throw ex;
            } else {
                doLenientDetection(httpContentType, ex);
            }
        }
    }

    public static String getEffectiveAddress(Exchange exchange, String defaultAddress) {
        String retval = exchange.getIn().getHeader(CxfConstants.DESTINATION_OVERRIDE_URL, String.class);
        if (retval == null) {
            retval = defaultAddress;
        } else {
            LOG.trace("Client address is overridden by header '{}' to value '{}'",
                    CxfConstants.DESTINATION_OVERRIDE_URL, retval);
        }
        return retval;
    }

    protected void doGet(Exchange exchange, String namespaceName) {
        String customResourceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_CRD_INSTANCE_NAME, String.class);
        if (ObjectHelper.isEmpty(customResourceName)) {
            throw new IllegalArgumentException("Get a specific custom resource require specify a custom resource name");
        }
        JsonObject customResourceJSON = new JsonObject();
        try {
            customResourceJSON = new JsonObject(
                    getEndpoint().getKubernetesClient().genericKubernetesResources(getCRDContext(exchange.getIn()))
                            .inNamespace(namespaceName)
                            .withName(customResourceName)
                            .require()
                            .get());

        } catch (KubernetesClientException e) {
            if (e.getCode() == 404) {
                LOG.info("Custom resource instance not found", e);
            } else {
                throw e;
            }
        }

        prepareOutboundMessage(exchange, customResourceJSON);
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "configuration": ((NettyHttpComponent) component).setConfiguration((org.apache.camel.component.netty.NettyConfiguration) value); return true;
            case "disconnect": getOrCreateConfiguration((NettyHttpComponent) component).setDisconnect((boolean) value); return true;
            case "keepAlive": getOrCreateConfiguration((NettyHttpComponent) component).setKeepAlive((boolean) value); return true;
            case "reuseAddress": getOrCreateConfiguration((NettyHttpComponent) component).setReuseAddress((boolean) value); return true;
            case "reuseChannel": getOrCreateConfiguration((NettyHttpComponent) component).setReuseChannel((boolean) value); return true;
            case "sync": getOrCreateConfiguration((NettyHttpComponent) component).setSync((boolean) value); return true;
            case "tcpNoDelay": getOrCreateConfiguration((NettyHttpComponent) component).setTcpNoDelay((boolean) value); return true;
            case "networkInterface": getOrCreateConfiguration((NettyHttpComponent) component).setNetworkInterface((java.lang.String) value); return true;
            case "bridgeErrorHandler": ((NettyHttpComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "clientMode": getOrCreateConfiguration((NettyHttpComponent) component).setClientMode((boolean) value); return true;
            case "muteException": ((NettyHttpComponent) component).setMuteException((boolean) value); return true;
            case "reconnect": getOrCreateConfiguration((NettyHttpComponent) component).setReconnect((boolean) value); return true;
            case "reconnectInterval": getOrCreateConfiguration((NettyHttpComponent) component).setReconnectInterval((int) value); return true;
            case "backlog": getOrCreateConfiguration((NettyHttpComponent) component).setBacklog((int) value); return true;
            case "bossCount": getOrCreateConfiguration((NettyHttpComponent) component).setBossCount((int) value); return true;
            case "bossGroup": getOrCreateConfiguration((NettyHttpComponent) component).setBossGroup((io.netty.channel.EventLoopGroup) value); return true;
            case "broadcast": getOrCreateConfiguration((NettyHttpComponent) component).setBroadcast((boolean) value); return true;
            case "disconnectOnNoReply": getOrCreateConfiguration((NettyHttpComponent) component).setDisconnectOnNoReply((boolean) value); return true;
            case "executorService": ((NettyHttpComponent) component).setExecutorService((io.netty.util.concurrent.EventExecutorGroup) value); return true;
            case "maximumPoolSize": ((NettyHttpComponent) component).setMaximumPoolSize((int) value); return true;
            case "nettyServerBootstrapFactory": getOrCreateConfiguration((NettyHttpComponent) component).setNettyServerBootstrapFactory((org.apache.camel.component.netty.NettyServerBootstrapFactory) value); return true;
            case "noReplyLogLevel": getOrCreateConfiguration((NettyHttpComponent) component).setNoReplyLogLevel((org.apache.camel.LoggingLevel) value); return true;
            case "serverClosedChannelExceptionCaughtLogLevel": getOrCreateConfiguration((NettyHttpComponent) component).setServerClosedChannelExceptionCaughtLogLevel((org.apache.camel.LoggingLevel) value); return true;
            case "serverExceptionCaughtLogLevel": getOrCreateConfiguration((NettyHttpComponent) component).setServerExceptionCaughtLogLevel((org.apache.camel.LoggingLevel) value); return true;
            case "serverInitializerFactory": getOrCreateConfiguration((NettyHttpComponent) component).setServerInitializerFactory((org.apache.camel.component.netty.ServerInitializerFactory) value); return true;
            case "usingExecutorService": getOrCreateConfiguration((NettyHttpComponent) component).setUsingExecutorService((boolean) value); return true;
            case "connectTimeout": getOrCreateConfiguration((NettyHttpComponent) component).setConnectTimeout((int) value); return true;
            case "lazyStartProducer": ((NettyHttpComponent) component).setLazyStartProducer((boolean) value); return true;
            case "requestTimeout": getOrCreateConfiguration((NettyHttpComponent) component).setRequestTimeout((long) value); return true;
            case "clientInitializerFactory": getOrCreateConfiguration((NettyHttpComponent) component).setClientInitializerFactory((org.apache.camel.component.netty.ClientInitializerFactory) value); return true;
            case "correlationManager": getOrCreateConfiguration((NettyHttpComponent) component).setCorrelationManager((org.apache.camel.component.netty.NettyCamelStateCorrelationManager) value); return true;
            case "lazyChannelCreation": getOrCreateConfiguration((NettyHttpComponent) component).setLazyChannelCreation((boolean) value); return true;
            case "producerPoolBlockWhenExhausted": getOrCreateConfiguration((NettyHttpComponent) component).setProducerPoolBlockWhenExhausted((boolean) value); return true;
            case "producerPoolEnabled": getOrCreateConfiguration((NettyHttpComponent) component).setProducerPoolEnabled((boolean) value); return true;
            case "producerPoolMaxIdle": getOrCreateConfiguration((NettyHttpComponent) component).setProducerPoolMaxIdle((int) value); return true;
            case "producerPoolMaxTotal": getOrCreateConfiguration((NettyHttpComponent) component).setProducerPoolMaxTotal((int) value); return true;
            case "producerPoolMaxWait": getOrCreateConfiguration((NettyHttpComponent) component).setProducerPoolMaxWait((long) value); return true;
            case "producerPoolMinEvictableIdle": getOrCreateConfiguration((NettyHttpComponent) component).setProducerPoolMinEvictableIdle((long) value); return true;
            case "producerPoolMinIdle": getOrCreateConfiguration((NettyHttpComponent) component).setProducerPoolMinIdle((int) value); return true;
            case "udpConnectionlessSending": getOrCreateConfiguration((NettyHttpComponent) component).setUdpConnectionlessSending((boolean) value); return true;
            case "useByteBuf": getOrCreateConfiguration((NettyHttpComponent) component).setUseByteBuf((boolean) value); return true;
            case "allowSerializedHeaders": getOrCreateConfiguration((NettyHttpComponent) component).setAllowSerializedHeaders((boolean) value); return true;
            case "autowiredEnabled": ((NettyHttpComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "channelGroup": getOrCreateConfiguration((NettyHttpComponent) component).setChannelGroup((io.netty.channel.group.ChannelGroup) value); return true;
            case "headerFilterStrategy": ((NettyHttpComponent) component).setHeaderFilterStrategy((org.apache.camel.spi.HeaderFilterStrategy) value); return true;
            case "nativeTransport": getOrCreateConfiguration((NettyHttpComponent) component).setNativeTransport((boolean) value); return true;
            case "nettyHttpBinding": ((NettyHttpComponent) component).setNettyHttpBinding((org.apache.camel.component.netty.http.NettyHttpBinding) value); return true;
            case "options": getOrCreateConfiguration((NettyHttpComponent) component).setOptions((java.util.Map) value); return true;
            case "receiveBufferSize": getOrCreateConfiguration((NettyHttpComponent) component).setReceiveBufferSize((int) value); return true;
            case "receiveBufferSizePredictor": getOrCreateConfiguration((NettyHttpComponent) component).setReceiveBufferSizePredictor((int) value); return true;
            case "sendBufferSize": getOrCreateConfiguration((NettyHttpComponent) component).setSendBufferSize((int) value); return true;
            case "shutdownTimeout": getOrCreateConfiguration((NettyHttpComponent) component).setShutdownTimeout((int) value); return true;
            case "transferExchange": getOrCreateConfiguration((NettyHttpComponent) component).setTransferExchange((boolean) value); return true;
            case "udpByteArrayCodec": getOrCreateConfiguration((NettyHttpComponent) component).setUdpByteArrayCodec((boolean) value); return true;
            case "unixDomainSocketPath": getOrCreateConfiguration((NettyHttpComponent) component).setUnixDomainSocketPath((java.lang.String) value); return true;
            case "workerCount": getOrCreateConfiguration((NettyHttpComponent) component).setWorkerCount((int) value); return true;
            case "workerGroup": getOrCreateConfiguration((NettyHttpComponent) component).setWorkerGroup((io.netty.channel.EventLoopGroup) value); return true;
            case "allowDefaultCodec": getOrCreateConfiguration((NettyHttpComponent) component).setAllowDefaultCodec((boolean) value); return true;
            case "autoAppendDelimiter": getOrCreateConfiguration((NettyHttpComponent) component).setAutoAppendDelimiter((boolean) value); return true;
            case "decoderMaxLineLength": getOrCreateConfiguration((NettyHttpComponent) component).setDecoderMaxLineLength((int) value); return true;
            case "decoders": getOrCreateConfiguration((NettyHttpComponent) component).setDecoders((java.lang.String) value); return true;
            case "delimiter": getOrCreateConfiguration((NettyHttpComponent) component).setDelimiter((org.apache.camel.component.netty.TextLineDelimiter) value); return true;
            case "encoders": getOrCreateConfiguration((NettyHttpComponent) component).setEncoders((java.lang.String) value); return true;
            case "encoding": getOrCreateConfiguration((NettyHttpComponent) component).setEncoding((java.lang.String) value); return true;
            case "textline": getOrCreateConfiguration((NettyHttpComponent) component).setTextline((boolean) value); return true;
            case "enabledProtocols": getOrCreateConfiguration((NettyHttpComponent) component).setEnabledProtocols((java.lang.String) value); return true;
            case "hostnameVerification": getOrCreateConfiguration((NettyHttpComponent) component).setHostnameVerification((boolean) value); return true;
            case "keyStoreFormat": getOrCreateConfiguration((NettyHttpComponent) component).setKeyStoreFormat((java.lang.String) value); return true;
            case "keyStoreResource": getOrCreateConfiguration((NettyHttpComponent) component).setKeyStoreResource((java.lang.String) value); return true;
            case "needClientAuth": getOrCreateConfiguration((NettyHttpComponent) component).setNeedClientAuth((boolean) value); return true;
            case "passphrase": getOrCreateConfiguration((NettyHttpComponent) component).setPassphrase((java.lang.String) value); return true;
            case "securityConfiguration": ((NettyHttpComponent) component).setSecurityConfiguration((org.apache.camel.component.netty.http.NettyHttpSecurityConfiguration) value); return true;
            case "securityProvider": getOrCreateConfiguration((NettyHttpComponent) component).setSecurityProvider((java.lang.String) value); return true;
            case "ssl": getOrCreateConfiguration((NettyHttpComponent) component).setSsl((boolean) value); return true;
            case "sslClientCertHeaders": getOrCreateConfiguration((NettyHttpComponent) component).setSslClientCertHeaders((boolean) value); return true;
            case "sslContextParameters": getOrCreateConfiguration((NettyHttpComponent) component).setSslContextParameters((org.apache.camel.support.jsse.SSLContextParameters) value); return true;
            case "sslHandler": getOrCreateConfiguration((NettyHttpComponent) component).setSslHandler((io.netty.handler.ssl.SslHandler) value); return true;
            case "trustStoreResource": getOrCreateConfiguration((NettyHttpComponent) component).setTrustStoreResource((java.lang.String) value); return true;
            case "useGlobalSslContextParameters": ((NettyHttpComponent) component).setUseGlobalSslContextParameters((boolean) value); return true;
            default: return false;
            }
        }

        public void run() {
             
            LOG.info("Listening on port {}", serversocket.getLocalPort());
            while (!Thread.interrupted()) {
                try {

                     
                    final Socket inSocket = serversocket.accept();

                     
                    final Thread t = new RequestHandlerThread(this.service.httpService, inSocket);
                    t.setDaemon(true);
                    t.start();
                } catch (final InterruptedIOException | SocketException ex) {
                     
                    break;
                } catch (final IOException e) {
                    LOG.error("I/O error initialising connection thread: {}", e.getMessage());
                    break;
                }
            }
        }

    public static <I1, I2, T extends Throwable> BiConsumer<I1, I2> wrapAsBiConsumer(ThrowingBiConsumer<I1, I2, T> consumer) {
        return new BiConsumer<>() {
            @Override
            public void accept(I1 i1, I2 i2) {
                try {
                    consumer.accept(i1, i2);
                } catch (Throwable t) {
                    throw new RuntimeException(t);
                }
            }
        };
    }

    public void copyFrom(GenericFile<T> source, GenericFile<T> result) {
        result.setCopyFromAbsoluteFilePath(source.getAbsoluteFilePath());
        result.setEndpointPath(source.getEndpointPath());
        result.setAbsolute(source.isAbsolute());
        result.setDirectory(source.isDirectory());
        result.setAbsoluteFilePath(source.getAbsoluteFilePath());
        result.setRelativeFilePath(source.getRelativeFilePath());
        result.setFileName(source.getFileName());
        result.setFileNameOnly(source.getFileNameOnly());
        result.setFileLength(source.getFileLength());
        result.setLastModified(source.getLastModified());
        result.setFile(source.getFile());
        result.setBody(source.getBody());
        result.setBinding(source.getBinding());
        result.setCharset(source.getCharset());

        copyFromPopulateAdditional(source, result);
    }

    public static String nodeValue(final int namespace, final String node) {
        Objects.requireNonNull(namespace);
        Objects.requireNonNull(node);

        final StringBuilder builder = new StringBuilder("RAW(");
        appendNamespace(builder, namespace);
        builder.append(';');
        appendNodeId(builder, node);
        builder.append(')');
        return builder.toString();
    }

    protected void doShutdown() throws Exception {
        super.doShutdown();

        if (cloudTrailClient != null) {
            try {
                cloudTrailClient.close();
            } catch (Exception e) {
                 
            }
            cloudTrailClient = null;
        }

        if (sqsClient != null) {
            try {
                sqsClient.close();
            } catch (Exception e) {
                 
            }
            sqsClient = null;
        }

        updates.clear();
    }

    private void doCreateOrUpdateJob(Exchange exchange, String operationName, Function<Resource<Job>, Job> operation) {
        String jobName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_JOB_NAME, String.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        JobSpec jobSpec = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_JOB_SPEC, JobSpec.class);
        HashMap<String, String> annotations
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_JOB_ANNOTATIONS, HashMap.class);
        if (ObjectHelper.isEmpty(jobName)) {
            LOG.error("{} a specific job require specify a job name", operationName);
            throw new IllegalArgumentException(String.format("%s a specific job require specify a job name", operationName));
        }
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific job require specify a namespace name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific job require specify a namespace name", operationName));
        }
        if (ObjectHelper.isEmpty(jobSpec)) {
            LOG.error("{} a specific job require specify a job spec bean", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific job require specify a job spec bean", operationName));
        }
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_JOB_LABELS, Map.class);
        JobBuilder jobCreatingBuilder = new JobBuilder();
        if (ObjectHelper.isEmpty(annotations)) {
            jobCreatingBuilder.withNewMetadata().withName(jobName).withLabels(labels).endMetadata()
                    .withSpec(jobSpec);
        } else {
            jobCreatingBuilder.withNewMetadata().withName(jobName).withLabels(labels).withAnnotations(annotations).endMetadata()
                    .withSpec(jobSpec);
        }
        Job job = operation.apply(
                getEndpoint().getKubernetesClient().batch().v1().jobs().inNamespace(namespaceName)
                        .resource(jobCreatingBuilder.build()));

        prepareOutboundMessage(exchange, job);
    }

    public HealthCheckRepository resolveHealthCheckRepository(String id) {
         
        HealthCheckRepository answer
                = camelContext.getRegistry().lookupByNameAndType(id + "-health-check-repository", HealthCheckRepository.class);
        if (answer == null) {
            answer = camelContext.getRegistry().lookupByNameAndType(id, HealthCheckRepository.class);
        }
        if (answer != null) {
            return answer;
        }

        Class<?> type = null;
        try {
            type = findHealthCheckRepository(id, camelContext);
        } catch (NoFactoryAvailableException e) {
             
        } catch (Exception e) {
            throw new IllegalArgumentException("Invalid URI, no HealthCheckRepository registered for id: " + id, e);
        }

        if (type != null) {
            if (HealthCheckRepository.class.isAssignableFrom(type)) {
                return (HealthCheckRepository) camelContext.getInjector().newInstance(type, false);
            } else {
                throw new IllegalArgumentException(
                        "Resolving health-check-repository: " + id
                                                   + " detected type conflict: Not a HealthCheckRepository implementation. Found: "
                                                   + type.getName());
            }
        }

        return null;
    }

    public void setLoggingFeatureEnabled(boolean loggingFeatureEnabled) {
        if (loggingFeature != null) {
            getFeatures().remove(loggingFeature);
            loggingFeature = null;
        }
        if (loggingFeatureEnabled) {
            if (getLoggingSizeLimit() > 0) {
                loggingFeature = new LoggingFeature();
                loggingFeature.setLimit(getLoggingSizeLimit());
            } else {
                loggingFeature = new LoggingFeature();
            }
            getFeatures().add(loggingFeature);
        }

    }

    private void getFunction(CloudFunctionsServiceClient client, Exchange exchange) throws InvalidPayloadException {
        CloudFunction response = null;
        if (getConfiguration().isPojoRequest()) {
            CloudFunctionName request = exchange.getIn().getMandatoryBody(CloudFunctionName.class);
            response = client.getFunction(request);
        } else {
            CloudFunctionName cfName = CloudFunctionName.of(getConfiguration().getProject(),
                    getConfiguration().getLocation(), getConfiguration().getFunctionName());
            response = client.getFunction(cfName);
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(response);
    }

    private void transferImage(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
        Integer imageId = exchange.getIn().getHeader(DigitalOceanHeaders.ID, Integer.class);

        if (ObjectHelper.isEmpty(imageId)) {
            throw new IllegalArgumentException(DigitalOceanHeaders.ID + " must be specified");
        }

        String region = exchange.getIn().getHeader(DigitalOceanHeaders.REGION, String.class);

        if (ObjectHelper.isEmpty(region)) {
            throw new IllegalArgumentException(DigitalOceanHeaders.REGION + " must be specified");
        }

        Action action = getEndpoint().getDigitalOceanClient().transferImage(imageId, region);
        LOG.trace("Transfer  Image {} to Region {} [{}] ", imageId, region, action);
        exchange.getMessage().setBody(action);
    }

    protected <T> T doGetCache(String key, String name, Function<String, T> loader) {
        if (caching) {
            T t = (T) cache.get(key);
            if (t == null) {
                t = loader.apply(name);
                if (t != null) {
                    cache.put(key, t);
                }
            }
            return t;
        } else {
            return loader.apply(name);
        }
    }

    protected void setupVmProtocol() {
        boolean minaLogger = configuration.isMinaLogger();
        List<IoFilter> filters = configuration.getFilters();

        address = new VmPipeAddress(configuration.getPort());
        connector = new VmPipeConnector();

         
        if (minaLogger) {
            connector.getFilterChain().addLast("logger", new LoggingFilter());
        }
        appendIoFiltersToChain(filters, connector.getFilterChain());
        if (configuration.getSslContextParameters() != null) {
            LOG.warn("Using vm protocol"
                     + ", but an SSLContextParameters instance was provided.  SSLContextParameters is only supported on the TCP protocol.");
        }
        configureCodecFactory("MinaProducer", connector);
    }

    protected void doStart() throws Exception {
        super.doStart();

        connectOptions = PahoEndpoint.createMqttConnectOptions(getEndpoint().getConfiguration());

        if (client == null) {
            clientId = getEndpoint().getConfiguration().getClientId();
            if (clientId == null) {
                clientId = "camel-" + MqttClient.generateClientId();
            }
            stopClient = true;
            client = new MqttClient(
                    getEndpoint().getConfiguration().getBrokerUrl(),
                    clientId,
                    PahoEndpoint.createMqttClientPersistence(getEndpoint().getConfiguration()));
            LOG.debug("Connecting client: {} to broker: {}", clientId, getEndpoint().getConfiguration().getBrokerUrl());
            if (getEndpoint().getConfiguration().isManualAcksEnabled()) {
                client.setManualAcks(true);

            }
            client.connect(connectOptions);
        }

        client.setCallback(new MqttCallbackExtended() {

            @Override
            public void connectComplete(boolean reconnect, String serverURI) {
                if (reconnect) {
                    try {
                        client.subscribe(getEndpoint().getTopic(), getEndpoint().getConfiguration().getQos());
                    } catch (MqttException e) {
                        LOG.error("MQTT resubscribe failed {}", e.getMessage(), e);
                    }
                }
            }

            @Override
            public void connectionLost(Throwable cause) {
                LOG.debug("MQTT broker connection lost due {}", cause.getMessage(), cause);
            }

            @Override
            public void messageArrived(String topic, MqttMessage message) throws Exception {
                LOG.debug("Message arrived on topic: {} -> {}", topic, message);
                Exchange exchange = createExchange(message, topic);

                 
                AsyncCallback cb = defaultConsumerCallback(exchange, true);
                getAsyncProcessor().process(exchange, cb);
            }

            @Override
            public void deliveryComplete(IMqttDeliveryToken token) {
                LOG.debug("Delivery complete. Token: {}", token);
            }
        });

        LOG.debug("Subscribing client: {} to topic: {}", clientId, getEndpoint().getTopic());
        client.subscribe(getEndpoint().getTopic(), getEndpoint().getConfiguration().getQos());
    }

    public static Expression collateExpression(final String expression, final int group) {
        return new ExpressionAdapter() {
            private Expression exp;

            @Override
            public void init(CamelContext context) {
                 
                exp = context.resolveLanguage("simple").createExpression(expression);
                exp.init(context);
                exp = ExpressionBuilder.groupIteratorExpression(exp, null, Integer.toString(group), false);
                exp.init(context);
            }

            @Override
            public Object evaluate(Exchange exchange) {
                return exp.evaluate(exchange, Object.class);
            }

            @Override
            public String toString() {
                return "collate(" + expression + "," + group + ")";
            }
        };
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            int headerIndex = 0;
            for (Expression expression : expressions) {
                Object newHeader = expression.evaluate(exchange, Object.class);

                if (exchange.getException() != null) {
                     
                    callback.done(true);
                    return true;
                }
                Message message = exchange.getMessage();
                String key = headerNames.get(headerIndex++).evaluate(exchange, String.class);
                message.setHeader(key, newHeader);
            }

        } catch (Exception e) {
            exchange.setException(e);
        }

        callback.done(true);
        return true;
    }

    protected void doListBuildByLabels(Exchange exchange) {
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_BUILDS_LABELS, Map.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        BuildList buildList;
        if (!ObjectHelper.isEmpty(namespaceName)) {
            buildList = getEndpoint().getKubernetesClient()
                    .adapt(OpenShiftClient.class).builds().inNamespace(namespaceName).withLabels(labels).list();
        } else {
            buildList = getEndpoint().getKubernetesClient().adapt(OpenShiftClient.class).builds()
                    .inAnyNamespace().withLabels(labels).list();
        }

        prepareOutboundMessage(exchange, buildList.getItems());
    }

    private static GenericFileExclusiveReadLockStrategy<File> newStrategyForIdempotentRename(
            Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<File> strategy;
        FileIdempotentRenameRepositoryReadLockStrategy readLockStrategy
                = new FileIdempotentRenameRepositoryReadLockStrategy();
        Boolean readLockRemoveOnRollback = (Boolean) params.get("readLockRemoveOnRollback");
        if (readLockRemoveOnRollback != null) {
            readLockStrategy.setRemoveOnRollback(readLockRemoveOnRollback);
        }
        Boolean readLockRemoveOnCommit = (Boolean) params.get("readLockRemoveOnCommit");
        if (readLockRemoveOnCommit != null) {
            readLockStrategy.setRemoveOnCommit(readLockRemoveOnCommit);
        }
        IdempotentRepository repo = (IdempotentRepository) params.get("readLockIdempotentRepository");
        if (repo != null) {
            readLockStrategy.setIdempotentRepository(repo);
        }
        strategy = readLockStrategy;
        return strategy;
    }

    public static DataFormatModel generateDataFormatModel(JsonObject obj) {
        JsonObject mobj = (JsonObject) obj.get("dataformat");
        DataFormatModel model = new DataFormatModel();
        parseModel(mobj, model);
        parseArtifact(mobj, model);
        model.setModelName(mobj.getString("modelName"));
        model.setModelJavaType(mobj.getString("modelJavaType"));
        JsonObject mprp = (JsonObject) obj.get("properties");
        for (Map.Entry<String, Object> entry : mprp.entrySet()) {
            JsonObject mp = (JsonObject) entry.getValue();
            DataFormatOptionModel option = new DataFormatOptionModel();
            parseOption(mp, option, entry.getKey());
            model.addOption(option);
        }
        return model;
    }

    protected void doStart() throws Exception {
        super.doStart();
        cache = CamelContextHelper.lookup(getCamelContext(), cacheName, Cache.class);
        if (cache == null) {
            if (configuration.isCreateCacheIfNotExist()) {
                cache = getComponent().getOrCreateCache(cacheName, configuration);
            } else {
                throw new IllegalArgumentException(
                        "Cache instance '" + cacheName + "' not found and createCacheIfNotExist is set to false");
            }
        }
    }

    protected void cloneBuilder(DefaultErrorHandlerDefinition other) {
        other.setExecutorServiceBean(getExecutorServiceBean());
        other.setExecutorServiceRef(getExecutorServiceRef());
        other.setLevel(getLevel());
        other.setLogName(getLogName());
        other.setLoggerBean(getLoggerBean());
        other.setLoggerRef(getLoggerRef());
        other.setOnExceptionOccurredProcessor(getOnExceptionOccurredProcessor());
        other.setOnExceptionOccurredRef(getOnExceptionOccurredRef());
        other.setOnPrepareFailureProcessor(getOnPrepareFailureProcessor());
        other.setOnPrepareFailureRef(getOnPrepareFailureRef());
        other.setOnRedeliveryProcessor(getOnRedeliveryProcessor());
        other.setOnRedeliveryRef(getOnRedeliveryRef());
        other.setRedeliveryPolicyRef(getRedeliveryPolicyRef());
        other.setRetryWhilePredicate(getRetryWhilePredicate());
        other.setRetryWhileRef(getRetryWhileRef());
        other.setUseOriginalBody(getUseOriginalBody());
        other.setUseOriginalMessage(getUseOriginalMessage());
        if (hasRedeliveryPolicy()) {
            other.setRedeliveryPolicy(getRedeliveryPolicy().copy());
        }
    }

                public void eventReceived(Action action, Deployment resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

    protected void afterConfigureProperties() {
        olingo4endpointPropertyNames
                = new HashSet<>(getPropertiesHelper().getValidEndpointProperties(getCamelContext(), configuration));
        olingo4endpointPropertyNames.add(EDM_PROPERTY);
        olingo4endpointPropertyNames.add(ENDPOINT_HTTP_HEADERS_PROPERTY);
        olingo4endpointPropertyNames.add(SERVICE_URI_PROPERTY);
        olingo4endpointPropertyNames.add(FILTER_ALREADY_SEEN);

         
        if (!(READ_METHOD.equals(methodName) || DELETE_METHOD.equals(methodName) || UREAD_METHOD.equals(methodName))
                && inBody == null) {
            inBody = DATA_PROPERTY;
        }
        createProxy();
    }

    protected void doPush(Exchange exchange, String operation) throws GitAPIException {
        Iterable<PushResult> result = null;
        try {
            if (ObjectHelper.isEmpty(endpoint.getRemoteName())) {
                throw new IllegalArgumentException("Remote name must be specified to execute " + operation);
            }
            if (ObjectHelper.isNotEmpty(endpoint.getBranchName())) {
                git.checkout().setCreateBranch(false).setName(endpoint.getBranchName()).call();
            }
            if (ObjectHelper.isNotEmpty(endpoint.getUsername()) && ObjectHelper.isNotEmpty(endpoint.getPassword())) {
                UsernamePasswordCredentialsProvider credentials
                        = new UsernamePasswordCredentialsProvider(endpoint.getUsername(), endpoint.getPassword());
                result = git.push().setCredentialsProvider(credentials).setRemote(endpoint.getRemoteName()).call();
            } else {
                result = git.push().setRemote(endpoint.getRemoteName()).call();
            }
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
        updateExchange(exchange, result);
    }

    public List<String> getAllowableValuesAsStringList() {
        if (allowableValues == null) {
            return Collections.emptyList();
        } else {
            List<String> answer = new ArrayList<>();
            for (ValueDefinition v : allowableValues) {
                answer.add(v.getValue());
            }
            return answer;
        }
    }

    private static JsonObject getStatsObject(ManagedProcessorMBean mpb) {
        JsonObject stats = new JsonObject();
        stats.put("exchangesTotal", mpb.getExchangesTotal());
        stats.put("exchangesFailed", mpb.getExchangesFailed());
        stats.put("exchangesInflight", mpb.getExchangesInflight());
        stats.put("meanProcessingTime", mpb.getMeanProcessingTime());
        stats.put("maxProcessingTime", mpb.getMaxProcessingTime());
        stats.put("minProcessingTime", mpb.getMinProcessingTime());
        stats.put("lastProcessingTime", mpb.getLastProcessingTime());
        stats.put("deltaProcessingTime", mpb.getDeltaProcessingTime());
        stats.put("totalProcessingTime", mpb.getTotalProcessingTime());
        return stats;
    }

    public void process(Exchange exchange, String message) {
        if (logger.shouldLog()) {
            String output = formatter.format(exchange) + message;
            if (maskingFormatter != null) {
                output = maskingFormatter.format(output);
            }
            output = fireListeners(exchange, output);
            logger.log(output);
            closeListeners(exchange, output);
        }
    }

    protected Publisher<Exchange> doRequest(String name, Exchange data) {
        ReactiveStreamsConsumer consumer = streamSubscriber(name).getConsumer();
        if (consumer == null) {
            throw new IllegalStateException("No consumers attached to the stream " + name);
        }

        return Mono.<Exchange> create(
                sink -> data.getExchangeExtension().addOnCompletion(new Synchronization() {
                    @Override
                    public void onComplete(Exchange exchange) {
                        sink.success(exchange);
                    }

                    @Override
                    public void onFailure(Exchange exchange) {
                        Throwable throwable = exchange.getException();
                        if (throwable == null) {
                            throwable = new IllegalStateException("Unknown Exception");
                        }

                        sink.error(throwable);
                    }
                })).doOnSubscribe(
                        subs -> consumer.process(data, ReactorStreamsConstants.EMPTY_ASYNC_CALLBACK));
    }

    public Map<String, Object> toMap() {
        JsonObject jo = new JsonObject();
        jo.put("alias", alias);
        if (aliasImplementation != null) {
            jo.put("aliasImplementation", aliasImplementation);
        }
        if (description != null) {
            jo.put("description", description);
        }
        if (serviceData != null) {
            jo.put("serviceData", serviceData);
        }
        return jo;
    }

    private void describeCluster(EksClient eksClient, Exchange exchange) throws InvalidPayloadException {
        executeOperation(
                exchange,
                DescribeClusterRequest.class,
                eksClient::describeCluster,
                () -> {
                    String clusterName = getRequiredHeader(exchange, EKS2Constants.CLUSTER_NAME, String.class,
                            "Cluster name must be specified");
                    return eksClient.describeCluster(DescribeClusterRequest.builder().name(clusterName).build());
                },
                "Describe Cluster",
                (DescribeClusterResponse response, Message message) -> {
                    if (response.cluster() != null) {
                        message.setHeader(EKS2Constants.CLUSTER_ARN, response.cluster().arn());
                    }
                });
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        Object payload = exchange.getIn().getBody();
        if (requestClass.isInstance(payload)) {
            try {
                result = pojoExecutor.apply(requestClass.cast(payload));
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        } else if (headerExecutor != null) {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        } else {
            throw new IllegalArgumentException(
                    String.format("The %s operation expects a %s instance as body",
                            operationName, requestClass.getSimpleName()));
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    public Edm getEdm(Map<String, String> endpointHttpHeaders) throws RuntimeCamelException {
        Edm localEdm = edm;
        if (localEdm == null) {
            lock.lock();
            try {

                localEdm = edm;
                if (localEdm == null) {

                    final CountDownLatch latch = new CountDownLatch(1);
                    final Exception[] error = new Exception[1];
                    olingo2App.read(null, "$metadata", null, endpointHttpHeaders, new Olingo2ResponseHandler<Edm>() {

                        @Override
                        public void onResponse(Edm response, Map<String, String> responseHeaders) {
                            edm = response;
                            latch.countDown();
                        }

                        @Override
                        public void onException(Exception ex) {
                            error[0] = ex;
                            latch.countDown();
                        }

                        @Override
                        public void onCanceled() {
                            error[0] = new RuntimeCamelException("OData HTTP request cancelled!");
                            latch.countDown();
                        }
                    });

                    try {
                         
                        latch.await();

                        final Exception ex = error[0];
                        if (ex != null) {
                            if (ex instanceof RuntimeCamelException) {
                                throw (RuntimeCamelException) ex;
                            } else {
                                final String message = ex.getMessage() != null ? ex.getMessage() : ex.getClass().getName();
                                throw new RuntimeCamelException("Error reading EDM: " + message, ex);
                            }
                        }

                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        throw new RuntimeCamelException(e.getMessage(), e);
                    }

                    localEdm = edm;
                }
            } finally {
                lock.unlock();
            }
        }

        return localEdm;
    }

    protected void doStart() throws Exception {
        super.doStart();
        if (getCamelContext() != null) {
            try {
                 
                getCamelContext().start();
            } finally {
                if (getCamelContext().isVetoStarted()) {
                    completed();
                }
            }
        }
    }

    private Integer downloadFromGist() throws Exception {
        StringJoiner all = new StringJoiner(",");

        fetchGistUrls(file, all);

        if (all.length() > 0) {
             
            if (!directory.equals(".")) {
                Path dirPath = Paths.get(directory);
                if (cleanDirectory) {
                     
                    CommandHelper.cleanExportDir(directory);
                }
                Files.createDirectories(dirPath);
            }

            CamelContext tiny = new DefaultCamelContext();
            try (GistResourceResolver resolver = new GistResourceResolver()) {
                resolver.setCamelContext(tiny);
                for (String u : all.toString().split(",")) {
                    Resource resource = resolver.resolve(u);
                    if (!resource.exists()) {
                        throw new ResourceDoesNotExist(resource);
                    }
                    String loc = resource.getLocation();
                    String name = FileUtil.stripPath(loc);
                    Path targetPath = Paths.get(directory, name);
                    try (OutputStream os = Files.newOutputStream(targetPath)) {
                        IOUtils.copy(resource.getInputStream(), os);
                    }
                }
            }
        }

        return 0;
    }

    private void listVoices(Exchange exchange) {
        TextToSpeech tts = getEndpoint().getTtsClient();
        if (tts == null) {
            throw new IllegalStateException("TTS client not initialized");
        }

        LOG.trace("Listing available voices");

        Voices voices = tts.listVoices().execute().getResult();

        Message message = getMessageForResponse(exchange);
        message.setBody(voices.getVoices());
    }

    protected List<Configurer<SSLEngine>> getSSLEngineConfigurers(SSLContext context) {

        final List<String> enabledCipherSuites = this.getCipherSuites() == null
                ? null : this.parsePropertyValues(this.getCipherSuites().getCipherSuite());

        final Patterns enabledCipherSuitePatterns;
        final Patterns defaultEnabledCipherSuitePatterns = this.getDefaultCipherSuitesFilter().getPatterns();

        if (this.getCipherSuitesFilter() != null) {
            enabledCipherSuitePatterns = this.getCipherSuitesFilter().getPatterns();
        } else {
            enabledCipherSuitePatterns = null;
        }

        final List<String> enabledSecureSocketProtocols = this.getSecureSocketProtocols() == null
                ? null : this.parsePropertyValues(this.getSecureSocketProtocols().getSecureSocketProtocol());

        final Patterns enabledSecureSocketProtocolsPatterns;
        final Patterns defaultEnabledSecureSocketProtocolsPatterns = this.getDefaultSecureSocketProcotolFilter().getPatterns();

        if (this.getSecureSocketProtocolsFilter() != null) {
            enabledSecureSocketProtocolsPatterns = this.getSecureSocketProtocolsFilter().getPatterns();
        } else {
            enabledSecureSocketProtocolsPatterns = null;
        }

         

        final boolean allowPassthrough = getAllowPassthrough();

         

        Configurer<SSLEngine> sslEngineConfigurer = new Configurer<>() {

            @Override
            public SSLEngine configure(SSLEngine engine) {

                Collection<String> filteredCipherSuites = BaseSSLContextParameters.this
                        .filter(enabledCipherSuites, Arrays.asList(engine.getSSLParameters().getCipherSuites()),
                                Arrays.asList(engine.getEnabledCipherSuites()),
                                enabledCipherSuitePatterns, defaultEnabledCipherSuitePatterns,
                                !allowPassthrough);

                if (LOG.isDebugEnabled()) {
                    LOG.debug(SSL_ENGINE_CIPHER_SUITE_LOG_MSG,
                            engine,
                            enabledCipherSuites,
                            enabledCipherSuitePatterns,
                            engine.getSSLParameters().getCipherSuites(),
                            engine.getEnabledCipherSuites(),
                            defaultEnabledCipherSuitePatterns,
                            filteredCipherSuites);
                }

                engine.setEnabledCipherSuites(filteredCipherSuites.toArray(new String[0]));

                Collection<String> filteredSecureSocketProtocols = BaseSSLContextParameters.this
                        .filter(enabledSecureSocketProtocols, Arrays.asList(engine.getSSLParameters().getProtocols()),
                                Arrays.asList(engine.getEnabledProtocols()),
                                enabledSecureSocketProtocolsPatterns, defaultEnabledSecureSocketProtocolsPatterns,
                                !allowPassthrough);

                if (LOG.isDebugEnabled()) {
                    LOG.debug(SSL_ENGINE_PROTOCOL_LOG_MSG,
                            engine,
                            enabledSecureSocketProtocols,
                            enabledSecureSocketProtocolsPatterns,
                            engine.getSSLParameters().getProtocols(),
                            engine.getEnabledProtocols(),
                            defaultEnabledSecureSocketProtocolsPatterns,
                            filteredSecureSocketProtocols);
                }

                engine.setEnabledProtocols(
                        filteredSecureSocketProtocols.toArray(new String[0]));

                return engine;
            }
        };

        List<Configurer<SSLEngine>> sslEngineConfigurers = new LinkedList<>();
        sslEngineConfigurers.add(sslEngineConfigurer);

        return sslEngineConfigurers;
    }

    private Consumer<Exchange> scheduleMessages() {
        return (exchange) -> {
            final Object inputBody = exchange.getMessage().getBody();
            Map<String, Object> applicationProperties
                    = exchange.getMessage().getHeader(ServiceBusConstants.APPLICATION_PROPERTIES, Map.class);
            if (applicationProperties == null) {
                applicationProperties = new HashMap<>();
            }
            propagateHeaders(exchange, applicationProperties);
            final String correlationId = exchange.getMessage().getHeader(ServiceBusConstants.CORRELATION_ID, String.class);
            final String sessionId = getConfiguration().getSessionId();

            if (inputBody instanceof Iterable<?>) {
                serviceBusSenderOperations.scheduleMessages(convertBodyToList((Iterable<?>) inputBody),
                        configurationOptionsProxy.getScheduledEnqueueTime(exchange),
                        configurationOptionsProxy.getServiceBusTransactionContext(exchange),
                        applicationProperties,
                        correlationId,
                        sessionId);
            } else {
                Object convertedBody = inputBody instanceof BinaryData ? inputBody
                        : getConfiguration().isBinary() ? convertBodyToBinary(exchange)
                        : exchange.getMessage().getBody(String.class);
                serviceBusSenderOperations.scheduleMessages(convertedBody,
                        configurationOptionsProxy.getScheduledEnqueueTime(exchange),
                        configurationOptionsProxy.getServiceBusTransactionContext(exchange),
                        applicationProperties,
                        correlationId,
                        sessionId);
            }
        };
    }

        public void run() {
            FilterWatchListDeletable<ConfigMap, ConfigMapList, Resource<ConfigMap>> w;

             
            String namespace = getEndpoint().getKubernetesConfiguration().getNamespace();
            String labelKey = getEndpoint().getKubernetesConfiguration().getLabelKey();
            String labelValue = getEndpoint().getKubernetesConfiguration().getLabelValue();
            String resourceName = getEndpoint().getKubernetesConfiguration().getResourceName();

            if (ObjectHelper.isEmpty(namespace)) {
                w = getEndpoint().getKubernetesClient().configMaps().inAnyNamespace();

                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = w.withLabel(labelKey, labelValue);
                }
            } else {
                final NonNamespaceOperation<ConfigMap, ConfigMapList, Resource<ConfigMap>> client
                        = getEndpoint().getKubernetesClient().configMaps().inNamespace(namespace);
                w = client;
                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = client.withLabel(labelKey, labelValue);
                } else if (ObjectHelper.isNotEmpty(resourceName)) {
                    w = (FilterWatchListDeletable<ConfigMap, ConfigMapList, Resource<ConfigMap>>) client.withName(resourceName);
                }
            }

            watch = w.watch(new Watcher<>() {

                @Override
                public void eventReceived(Action action, ConfigMap resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

                @Override
                public void onClose(WatcherException cause) {
                    if (cause != null) {
                        LOG.error(cause.getMessage(), cause);
                    }
                }
            });
        }

    public InputStream loadResourceAsStream(String uri) {
        resourceResolverListeners.forEach(l -> l.onLoadResourceAsStream(uri));

        InputStream answer = null;
        try {
            answer = super.loadResourceAsStream(uri);
        } catch (Exception e) {
             
        }

        if (answer == null) {
             
            MavenGav gav = knownDependenciesResolver.mavenGavForClass(uri);
            if (gav == null) {
                 
                 
                String last = StringHelper.afterLast(uri, ".", uri);
                PojoBeanModel model = catalog.pojoBeanModel(last);
                if (model != null && uri.equals(model.getJavaType())) {
                    gav = MavenGav.fromCoordinates(model.getGroupId(), model.getArtifactId(), model.getVersion(), null, null);
                }
            }
            if (gav != null) {
                if (!downloader.alreadyOnClasspath(gav.getGroupId(), gav.getArtifactId(),
                        gav.getVersion())) {
                    downloader.downloadDependency(gav.getGroupId(), gav.getArtifactId(),
                            gav.getVersion());
                }
                try {
                    answer = super.loadResourceAsStream(uri);
                } catch (Exception e) {
                     
                }
            }
        }

        return answer;
    }

    private void handleNotFound(
            ConfigurationPropertiesValidationResult result, String value, String longKey, List<String> enums) {
        result.addInvalidEnum(longKey, value);
        result.addInvalidEnumChoices(longKey, enums.toArray(new String[0]));
        if (suggestionStrategy != null) {
            Set<String> names = new LinkedHashSet<>(enums);
            String[] suggestions = suggestionStrategy.suggestEndpointOptions(names, value);
            if (suggestions != null) {
                result.addInvalidEnumSuggestions(longKey, suggestions);
            }
        }
    }

    private void setupCommonServices() throws Exception {
        BacklogTracer backlogTracer = getBeanForType(BacklogTracer.class);
        if (backlogTracer != null) {
            LOG.info("Using custom BacklogTracer: {}", backlogTracer);
            getContext().addService(backlogTracer);
        }
        InflightRepository inflightRepository = getBeanForType(InflightRepository.class);
        if (inflightRepository != null) {
            LOG.info("Using custom InflightRepository: {}", inflightRepository);
            getContext().setInflightRepository(inflightRepository);
        }
        AsyncProcessorAwaitManager asyncProcessorAwaitManager = getBeanForType(AsyncProcessorAwaitManager.class);
        if (asyncProcessorAwaitManager != null) {
            LOG.info("Using custom AsyncProcessorAwaitManager: {}", asyncProcessorAwaitManager);
            getContext().getCamelContextExtension().addContextPlugin(AsyncProcessorAwaitManager.class,
                    asyncProcessorAwaitManager);
        }
        ManagementStrategy managementStrategy = getBeanForType(ManagementStrategy.class);
        if (managementStrategy != null) {
            LOG.info("Using custom ManagementStrategy: {}", managementStrategy);
            getContext().setManagementStrategy(managementStrategy);
        }
        ManagementObjectNameStrategy managementObjectNameStrategy = getBeanForType(ManagementObjectNameStrategy.class);
        if (managementObjectNameStrategy != null) {
            LOG.info("Using custom ManagementObjectNameStrategy: {}", managementObjectNameStrategy);
            getContext().getManagementStrategy().setManagementObjectNameStrategy(managementObjectNameStrategy);
        }
        EventFactory eventFactory = getBeanForType(EventFactory.class);
        if (eventFactory != null) {
            LOG.info("Using custom EventFactory: {}", eventFactory);
            getContext().getManagementStrategy().setEventFactory(eventFactory);
        }
        UnitOfWorkFactory unitOfWorkFactory = getBeanForType(UnitOfWorkFactory.class);
        if (unitOfWorkFactory != null) {
            LOG.info("Using custom UnitOfWorkFactory: {}", unitOfWorkFactory);
            getContext().getCamelContextExtension().addContextPlugin(UnitOfWorkFactory.class, unitOfWorkFactory);
        }
        RuntimeEndpointRegistry runtimeEndpointRegistry = getBeanForType(RuntimeEndpointRegistry.class);
        if (runtimeEndpointRegistry != null) {
            LOG.info("Using custom RuntimeEndpointRegistry: {}", runtimeEndpointRegistry);
            getContext().setRuntimeEndpointRegistry(runtimeEndpointRegistry);
        }
        EndpointServiceRegistry endpointServiceRegistry = getBeanForType(EndpointServiceRegistry.class);
        if (endpointServiceRegistry != null) {
            LOG.info("Using custom EndpointServiceRegistry: {}", endpointServiceRegistry);
            getContext().getCamelContextExtension().addContextPlugin(EndpointServiceRegistry.class, endpointServiceRegistry);
        }
        HeadersMapFactory headersMapFactory = getBeanForType(HeadersMapFactory.class);
        if (headersMapFactory != null) {
            LOG.info("Using custom HeadersMapFactory: {}", headersMapFactory);
            getContext().getCamelContextExtension().setHeadersMapFactory(headersMapFactory);
        }
    }

    public static Expression fileParentExpression() {
        return new ExpressionAdapter() {
            @Override
            public Object evaluate(Exchange exchange) {
                return exchange.getIn().getHeader("CamelFileParent", String.class);
            }

            @Override
            public String toString() {
                return "file:parent";
            }
        };
    }

    private OperationResult synchronouslySetData(ProductionContext ctx) throws Exception {

        SetDataOperation setData = new SetDataOperation(ctx.connection, ctx.node, ctx.payload);
        setData.setVersion(ctx.version);

        OperationResult result = setData.get();

        if (!result.isOk() && configuration.isCreate() && result.failedDueTo(Code.NONODE)) {
            LOG.warn("Node '{}' did not exist, creating it.", ctx.node);
            result = createNode(ctx);
        }
        return result;
    }

    public String resolveStaticUri(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        String destination = parseTopicName(entry.getUri());
        if (destination != null) {
            String originalDestination = parseTopicName(entry.getOriginalUri());
            if (!destination.equals(originalDestination)) {
                 
                String answer = entry.getUri();
                answer = StringHelper.replaceFirst(answer, destination, originalDestination);
                return answer;
            }
        }
        return null;
    }

    public void addConsumer(String key, DirectConsumer consumer) {
        consumersLock.lock();
        try {
            if (consumers.putIfAbsent(key, consumer) != null) {
                throw new IllegalArgumentException(
                        "Cannot add a 2nd consumer to the same endpoint: " + key
                                                   + ". DirectEndpoint only allows one consumer.");
            }
             
            stateCounter++;
            consumersCondition.signalAll();
        } finally {
            consumersLock.unlock();
        }
    }

    public void whenComplete(BiConsumer<BackOffTimer.Task, Throwable> whenCompleted) {
        lock.lock();
        try {
            if (backOff.isRemoveOnComplete()) {
                timer.remove(this);
            }
            consumers.add(whenCompleted);
        } finally {
            lock.unlock();
        }
    }

        public XmlSignatureProperties.Input build() {
            return new XmlSignatureProperties.Input() {

                @Override
                public XMLSignatureFactory getSignatureFactory() {
                    return signatureFactory;
                }

                @Override
                public String getSignatureAlgorithm() {
                    return signatureAlgorithm;
                }

                @Override
                public Node getParent() {
                    return parent;
                }

                @Override
                public Node getMessageBodyNode() {
                    return messageBodyNode;
                }

                @Override
                public Message getMessage() {
                    return message;
                }

                @Override
                public KeyInfo getKeyInfo() {
                    return keyInfo;
                }

                @Override
                public String getContentDigestAlgorithm() {
                    return contentDigestAlgorithm;
                }

                @Override
                public String getSignatureId() {
                    return signatureId;
                }

                @Override
                public String getContentReferenceUri() {
                    return contentReferenceUri;
                }

                @Override
                public SignatureType getSignatureType() {
                    return signatureType;
                }

                @Override
                public String getPrefixForXmlSignatureNamespace() {
                    return prefixForXmlSignatureNamespace;
                }

            };
        }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }

        EndpointMappingKey other = (EndpointMappingKey) obj;
        if (lookupKey == null) {
            if (other.lookupKey != null) {
                return false;
            }
        } else if (!lookupKey.equals(other.lookupKey)) {
            return false;
        }
        return true;
    }

    public MessageHistory newMessageHistory(String routeId, NamedNode namedNode, Exchange exchange) {
        if (nodePattern != null) {
            String name = namedNode.getShortName();
            String[] parts = nodePattern.split(",");
            for (String part : parts) {
                boolean match = PatternHelper.matchPattern(name, part);
                if (!match) {
                    return null;
                }
            }
        }

        Message msg = null;
        if (copyMessage) {
            msg = exchange.getMessage().copy();
        }

        Route route = camelContext.getRoute(routeId);
        if (route != null) {
            return new MicrometerMessageHistory(getMeterRegistry(), route, namedNode, getNamingStrategy(), msg);
        } else {
            return null;
        }
    }

    private Queue<Exchange> pollAdminEvents() throws Exception {
        Keycloak keycloakClient = getEndpoint().getKeycloakClient();
        KeycloakConfiguration config = getEndpoint().getConfiguration();
        String realm = config.getRealm();

        if (realm == null) {
            throw new IllegalArgumentException("Realm must be specified for consuming admin events");
        }

         
         
         
        List<String> adminOperationTypes = parseCommaSeparatedList(config.getOperationTypes());
        List<AdminEventRepresentation> adminEvents = keycloakClient.realm(realm).getAdminEvents(
                adminOperationTypes,  
                config.getAuthRealmFilter(),  
                config.getAuthClient(),  
                config.getAuthUser(),  
                config.getAuthIpAddress(),  
                config.getResourcePath(),  
                config.getDateFrom(),  
                config.getDateTo(),  
                config.getFirst(),  
                config.getMaxResults()  
        );

        Queue<Exchange> queue = new LinkedList<>();
        long highestEventTime = lastEventTime != null ? lastEventTime : 0;

        for (AdminEventRepresentation adminEvent : adminEvents) {
            long eventTime = adminEvent.getTime();

             
            if (lastEventTime != null && eventTime < lastEventTime) {
                continue;
            }

             
            String fingerprint = getAdminEventFingerprint(adminEvent);

             
            if (processedEventFingerprints.contains(fingerprint)) {
                LOG.trace("Skipping already processed admin event: {}", fingerprint);
                continue;
            }

            Exchange exchange = createExchange(false);
            exchange.getIn().setBody(adminEvent);
            exchange.getIn().setHeader(KeycloakConstants.EVENT_TYPE, "admin-event");
            exchange.getIn().setHeader(KeycloakConstants.EVENT_ID, adminEvent.getTime());
            exchange.getIn().setHeader(KeycloakConstants.REALM_NAME, realm);
            queue.add(exchange);

             
            processedEventFingerprints.add(fingerprint);

             
            if (eventTime > highestEventTime) {
                highestEventTime = eventTime;
            }

             
            if (processedEventFingerprints.size() > MAX_FINGERPRINT_CACHE_SIZE) {
                 
                 
                processedEventFingerprints.clear();
                LOG.debug("Cleared fingerprint cache due to size limit");
            }
        }

         
        if (highestEventTime > (lastEventTime != null ? lastEventTime : 0)) {
             
            processedEventFingerprints.clear();
            lastEventTime = highestEventTime;
            LOG.debug("Updated last admin event time to: {}", lastEventTime);
        }

        return queue;
    }

    private void processCloseJob(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        String jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
        bulkClient.changeJobState(jobId, JobStateEnum.UPLOAD_COMPLETE, determineHeaders(exchange),
                new JobResponseCallback() {
                    @Override
                    public void onResponse(Job job, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, job, headers, ex, callback);
                    }
                });
    }

    private static String doGetHost(RestConfiguration config) throws UnknownHostException {
        String host = config.getHost();
        if (ObjectHelper.isEmpty(host)) {
            if (config.getHostNameResolver() == RestConfiguration.RestHostNameResolver.allLocalIp) {
                host = "0.0.0.0";
            } else if (config.getHostNameResolver() == RestConfiguration.RestHostNameResolver.localHostName) {
                host = HostUtils.getLocalHostName();
            } else if (config.getHostNameResolver() == RestConfiguration.RestHostNameResolver.localIp) {
                host = HostUtils.getLocalIp();
            }
        }
        return host;
    }

    private static List<String> getDependencies(Object kamelet) throws Exception {
        List<String> answer = new ArrayList<>();
        Method m = kamelet.getClass().getMethod("getSpec");
        Object spec = ObjectHelper.invokeMethod(m, kamelet);
        m = spec.getClass().getMethod("getDependencies");
        @SuppressWarnings("unchecked")
        List<Object> list = (List<Object>) ObjectHelper.invokeMethod(m, spec);
        if (list != null && !list.isEmpty()) {
            for (var en : list) {
                String t = en.toString();
                t = StringHelper.removeLeadingAndEndingQuotes(t);
                answer.add(t);
            }
        }
        return answer.isEmpty() ? null : answer;
    }

    public String apply(String remainder) {
        String key = remainder;
        String defaultValue = null;

        if (remainder.contains(":")) {
            key = StringHelper.before(remainder, ":");
            defaultValue = StringHelper.after(remainder, ":");
        }

         
        if (key != null) {
             
            String port = IOHelper.lookupEnvironmentVariable(key + PORT_PREFIX);
            if (port != null) {
                return port;
            } else {
                return defaultValue;
            }
        }

        return defaultValue;
    }

    protected boolean matchSecret(String name) {
        Set<String> set = new HashSet<>();
        if (configmaps != null) {
            Collections.addAll(set, configmaps.split(","));
        }

        for (String part : set) {
            boolean result = name.contains(part) || PatternHelper.matchPattern(name, part);
            LOG.trace("Matching configmap id: {}={} -> {}", name, part, result);
            if (result) {
                return true;
            }
        }

        return false;
    }

    private void rebootInstances(Ec2Client ec2Client, Exchange exchange) throws InvalidPayloadException {
        Collection<String> instanceIds;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RebootInstancesRequest) {
                try {
                    LOG.trace("Rebooting instances with Ids [{}] ", ((RebootInstancesRequest) payload).instanceIds());
                    ec2Client.rebootInstances((RebootInstancesRequest) payload);
                } catch (AwsServiceException ase) {
                    LOG.trace("Reboot Instances command returned the error code {}", ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            }
        } else {
            RebootInstancesRequest.Builder builder = RebootInstancesRequest.builder();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(AWS2EC2Constants.INSTANCES_IDS))) {
                instanceIds = exchange.getIn().getHeader(AWS2EC2Constants.INSTANCES_IDS, Collection.class);
                builder.instanceIds(instanceIds);
            } else {
                throw new IllegalArgumentException(MISSING_INSTANCES_MESSAGE);
            }
            try {
                if (LOG.isTraceEnabled()) {
                    LOG.trace("Rebooting instances with Ids [{}] ", Arrays.toString(instanceIds.toArray()));
                }

                ec2Client.rebootInstances(builder.build());
            } catch (AwsServiceException ase) {
                LOG.trace("Reboot Instances command returned the error code {}", ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
    }

    public Exchange recover(CamelContext camelContext, final String exchangeId) {
        Exchange answer = null;

        try {
            byte[] completedLDBKey = keyBuilder(getRepositoryNameCompleted(), exchangeId);

            byte[] rc = levelDBFile.getDb().get(completedLDBKey);

            if (rc != null) {
                answer = codec().unmarshallExchange(camelContext, rc);
            }
        } catch (IOException e) {
            throw new RuntimeCamelException(
                    "Error recovering exchangeId " + exchangeId + " from repository " + repositoryName, e);
        }

        LOG.debug("Recovering exchangeId [{}] -> {}", exchangeId, answer);
        return answer;
    }

    public ProducerTemplate getObject() throws Exception {
        CamelContext context = getCamelContext();
        if (defaultEndpoint != null) {
            Endpoint endpoint = context.getEndpoint(defaultEndpoint);
            if (endpoint == null) {
                throw new IllegalArgumentException("No endpoint found for URI: " + defaultEndpoint);
            } else {
                template = new DefaultProducerTemplate(context, endpoint);
            }
        } else {
            template = new DefaultProducerTemplate(context);
        }

         
        if (maximumCacheSize != null) {
            template.setMaximumCacheSize(maximumCacheSize);
        }

         
        ServiceHelper.startService(template);
        return template;
    }

    public Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
        if (!allowNullOldExchange && oldExchange == null) {
            return newExchange;
        }
        if (!allowNullNewExchange && newExchange == null) {
            return oldExchange;
        }

        try {
            Object out = function.apply(oldExchange, newExchange);
            if (out != null && !(out instanceof Exchange)) {
                if (oldExchange != null) {
                    oldExchange.getIn().setBody(out);
                } else {
                    newExchange.getIn().setBody(out);
                }
            }
        } catch (Exception e) {
            if (oldExchange != null) {
                oldExchange.setException(e);
            } else {
                newExchange.setException(e);
            }
        }
        return oldExchange != null ? oldExchange : newExchange;
    }

    private void send(Exchange exchange) throws Exception {

        GooglePubsubEndpoint endpoint = (GooglePubsubEndpoint) getEndpoint();
        String topicName = String.format("projects/%s/topics/%s", endpoint.getProjectId(), endpoint.getDestinationName());

        Publisher publisher = endpoint.getComponent().getPublisher(topicName, endpoint);

        Object body = exchange.getIn().getBody();
        ByteString byteString;

        if (body instanceof String) {
            byteString = ByteString.copyFromUtf8((String) body);
        } else if (body instanceof byte[]) {
            byteString = ByteString.copyFrom((byte[]) body);
        } else {
            byteString = ByteString.copyFrom(endpoint.getSerializer().serialize(body));
        }

        PubsubMessage.Builder messageBuilder = PubsubMessage.newBuilder().setData(byteString);

         
         
        Map<String, String> attributes = exchange.getIn().getHeader(ATTRIBUTES, Map.class);
        if (attributes != null) {
            for (Map.Entry<String, String> attribute : attributes.entrySet()) {
                if (!attribute.getKey().startsWith(RESERVED_GOOGLE_CLIENT_ATTRIBUTE_PREFIX)) {
                    messageBuilder.putAttributes(attribute.getKey(), attribute.getValue());
                }
            }
        }
         

        String orderingKey = exchange.getIn().getHeader(ORDERING_KEY, String.class);
        if (orderingKey != null) {
            messageBuilder.setOrderingKey(orderingKey);
        }

         
        for (String camelHeader : exchange.getIn().getHeaders().keySet()) {
            String value = exchange.getIn().getHeader(camelHeader, String.class);
            if (headerFilterStrategy != null
                    && headerFilterStrategy.applyFilterToExternalHeaders(camelHeader, value, exchange)) {
                continue;
            }
            messageBuilder.putAttributes(camelHeader, value);
        }

        PubsubMessage message = messageBuilder.build();

        ApiFuture<String> messageIdFuture = publisher.publish(message);
        exchange.getIn().setHeader(GooglePubsubConstants.MESSAGE_ID, messageIdFuture.get());
    }

    private AvroSchema computeIfAbsent(Exchange exchange) {
        if (this.schema != null) {
            return this.schema;
        }

        AvroSchema answer = exchange.getProperty(SchemaHelper.CONTENT_SCHEMA, AvroSchema.class);

        if (answer == null && exchange.getProperties().containsKey(SchemaHelper.SCHEMA)) {
            String schemaJson = exchange.getProperty(SchemaHelper.SCHEMA, String.class);
            Schema raw = new Schema.Parser(NameValidator.UTF_VALIDATOR).parse(schemaJson);
            answer = new AvroSchema(raw);
        }

        if (answer == null) {
            String contentClass = SchemaHelper.resolveContentClass(exchange, this.contentClass);
            if (contentClass != null) {
                answer = this.schemes.computeIfAbsent(contentClass, t -> {
                    Resource res = PluginHelper.getResourceLoader(exchange.getContext())
                            .resolveResource("classpath:schemas/" + SchemaType.AVRO.name().toLowerCase(Locale.US) + "/" + t
                                             + "." + SchemaType.AVRO.type());

                    try {
                        if (res.exists()) {
                            try (InputStream is = res.getInputStream()) {
                                if (is != null) {
                                    return Avro.mapper().schemaFrom(is);
                                }
                            }
                        }
                    } catch (Exception e) {
                        throw new RuntimeException(
                                "Unable to load Avro schema for type: " + t + ", resource: " + res.getLocation(), e);
                    }

                    try {
                        return Avro.mapper().schemaFor(Class.forName(contentClass));
                    } catch (JsonMappingException | ClassNotFoundException e) {
                        throw new RuntimeException(
                                "Unable to compute Avro schema for type: " + t, e);
                    }
                });
            }
        }

        if (answer != null) {
            this.schema = answer;
        }

        return answer;
    }

    private String getLoad(Row r) {
        String s1 = r.load01 != null ? r.load01 : "-";
        String s2 = r.load05 != null ? r.load05 : "-";
        String s3 = r.load15 != null ? r.load15 : "-";
        if ("0.00".equals(s1)) {
            s1 = "-";
        }
        if ("0.00".equals(s2)) {
            s2 = "-";
        }
        if ("0.00".equals(s3)) {
            s3 = "-";
        }
        if (s1.equals("-") && s2.equals("-") && s3.equals("-")) {
            return "0/0/0";
        }
        return s1 + "/" + s2 + "/" + s3;
    }

        public void fromApp(Message message, SessionID sessionID)
                throws FieldNotFound, IncorrectDataFormat, IncorrectTagValue, UnsupportedMessageType {
            try {
                dispatch(QuickfixjEventCategory.AppMessageReceived, sessionID, message);
            } catch (RuntimeException e) {
                throw e;
            } catch (Exception e) {
                rethrowIfType(e, FieldNotFound.class);
                rethrowIfType(e, IncorrectDataFormat.class);
                rethrowIfType(e, IncorrectTagValue.class);
                rethrowIfType(e, UnsupportedMessageType.class);
                throw new DispatcherException(e);
            }
        }

    public void close() throws IOException {
        Subscription subscription;
        lock.lock();
        try {
            subscription = this.subscription;
        } finally {
            lock.unlock();
        }

        if (subscription != null) {
            subscription.cancel();
        }
    }

    public MessageHistory newMessageHistory(String routeId, NamedNode namedNode, Exchange exchange) {
        if (nodePattern != null) {
            String name = namedNode.getShortName();
            String[] parts = nodePattern.split(",");
            boolean match = false;
            for (String part : parts) {
                if (PatternHelper.matchPattern(name, part)) {
                    match = true;
                    break;
                }
            }
             
            if (!match) {
                return null;
            }
        }

        Message msg = null;
        if (copyMessage) {
            msg = exchange.getMessage().copy();
        }

        Route route = camelContext.getRoute(routeId);
        if (route != null) {
            return new OpenTelemetryMessageHistory(timer, getTimeUnit(), route, namedNode, getNamingStrategy(), msg);
        } else {
            return null;
        }
    }

        public DataFormatCustomizer build(ThrowingBiConsumer<String, T, Exception> consumer) {
            final int order = this.order;
            final BiPredicate<String, DataFormat> condition = condition();

            return new DataFormatCustomizer() {
                @SuppressWarnings("unchecked")
                @Override
                public void configure(String name, DataFormat target) {
                    ObjectHelper.notNull(name, "data format name");
                    ObjectHelper.notNull(target, "data format instance");

                    try {
                        consumer.accept(name, (T) target);
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }

                @Override
                public boolean isEnabled(String name, DataFormat target) {
                    ObjectHelper.notNull(name, "data format name");
                    ObjectHelper.notNull(target, "data format instance");

                    return condition.test(name, target);
                }

                @Override
                public int getOrder() {
                    return order;
                }
            };
        }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulSessionProducer target = (org.apache.camel.component.consul.endpoint.ConsulSessionProducer) obj;
        switch (key) {
        case "create":
        case "CREATE": target.create(exchange.getMessage()); return null;
        case "destroy":
        case "DESTROY": target.destroy(exchange.getMessage()); return null;
        case "info":
        case "INFO": target.info(exchange.getMessage()); return null;
        case "list":
        case "LIST": target.list(exchange.getMessage()); return null;
        case "renew":
        case "RENEW": target.renew(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public CouchDbEndpoint(String endpointUri, String remaining, CouchDbComponent component) throws Exception {
        super(endpointUri, component);

        URI uri = new URI(remaining);

        protocol = uri.getScheme();
        if (protocol == null) {
            throw new IllegalArgumentException(URI_ERROR);
        }

        port = uri.getPort() == -1 ? DEFAULT_PORT : uri.getPort();

        if (uri.getPath() == null || uri.getPath().isBlank()) {
            throw new IllegalArgumentException(URI_ERROR);
        }
        database = uri.getPath().substring(1);

        hostname = uri.getHost();
        if (hostname == null) {
            throw new IllegalArgumentException(URI_ERROR);
        }
    }

    protected List<String> determineEncryptionUserIds(Exchange exchange) {
        String userid = findKeyUserid(exchange);
        List<String> userids = findKeyUserids(exchange);
         
        List<String> result;
        if (userid != null) {
            if (userids == null || userids.isEmpty()) {
                result = Collections.singletonList(userid);
            } else {
                result = new ArrayList<>(userids.size() + 1);
                result.add(userid);
                result.addAll(userids);
            }
        } else {
            if (userids == null || userids.isEmpty()) {
                throw new IllegalStateException("Cannot PGP encrypt message. No User ID of the public key specified.");
            }
            result = userids;
        }
        return result;
    }

    private static String pathAsKey(String path) {
         
        if (path == null || path.equals("/")) {
            path = "";
        }

         
        path = StringHelper.before(path, "?", path);

         
        if (path.endsWith("/")) {
            path = path.substring(0, path.length() - 1);
        }

        return UnsafeUriCharactersEncoder.encodeHttpURI(path);
    }

    public Map<String, String> getServiceMetadata() {
        Map<String, String> map = new HashMap<>();
        if (configuration.getClientId() != null) {
            map.put("clientId", configuration.getClientId());
        }
        if (configuration.getUserName() != null) {
            map.put("username", configuration.getUserName());
        }
        return map.isEmpty() ? null : map;
    }

    public static List<RestConfigurationDetails> parseRestConfiguration(
            InputStream xml, String fullyQualifiedFileName) {
         
        Document dom = null;
        try {
            dom = XmlLineNumberParser.parseXml(xml);
        } catch (Exception e) {
             
        }
        if (dom != null) {
            CamelXmlRestDslParserHelper parser = new CamelXmlRestDslParserHelper();
            return parser.parseRestConfiguration(dom, fullyQualifiedFileName);
        }

        return Collections.emptyList();
    }

    public Integer doCall() throws Exception {
        int exit;
        final AtomicBoolean running = new AtomicBoolean(true);
        if (watch) {
            Thread t = new Thread(() -> {
                waitUserTask = new CommandHelper.ReadConsoleTask(() -> running.set(false));
                waitUserTask.run();
            }, "WaitForUser");
            t.start();
            do {
                exit = doWatchCall();
                if (exit == 0) {
                     
                    try {
                        StopWatch watch = new StopWatch();
                        while (running.get() && watch.taken() < 2000) {
                            Thread.sleep(100);
                        }
                    } catch (Exception e) {
                        running.set(false);
                    }
                }
            } while (exit == 0 && running.get());
        } else {
            exit = doWatchCall();
        }
        return exit;
    }

    private void processAbortJob(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        JobInfo jobBody;
        String jobId;
        jobBody = exchange.getIn().getBody(JobInfo.class);
        if (jobBody != null) {
            jobId = jobBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.abortJob(jobId, determineHeaders(exchange), new BulkApiClient.JobInfoResponseCallback() {
            @Override
            public void onResponse(JobInfo jobInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, jobInfo, headers, ex, callback);
            }
        });
    }

    public FluentProducerTemplate withExchangeProperties(Map<String, Object> properties) {
        DefaultFluentProducerTemplate clone = checkCloned();

        if (clone.processorSupplier != null) {
            throw new IllegalArgumentException(
                    "Cannot use both withExchangeProperties and withProcessor with FluentProducerTemplate");
        }

        Map<String, Object> map = clone.exchangeProperties;
        if (map == null) {
            map = new LinkedHashMap<>();
            clone.exchangeProperties = map;
        }
        map.putAll(properties);
        return clone;
    }

    public <T> T lookupByNameAndType(String name, Class<T> type) {
        Object object = lookupByName(name);
        if (object == null) {
            return null;
        }
        try {
            return type.cast(object);
        } catch (Exception e) {
            String msg = "Found bean: " + name + " in Consul Registry: " + this + " of type: " + object.getClass().getName()
                         + "expected type was: " + type;
            throw new NoSuchBeanException(name, msg, e);
        }
    }

    private GoogleSheetsApiCollection() {
        final Map<String, String> aliases = new HashMap<>();
        final Map<GoogleSheetsApiName, ApiMethodHelper<? extends ApiMethod>> apiHelpers = new EnumMap<>(GoogleSheetsApiName.class);
        final Map<Class<? extends ApiMethod>, GoogleSheetsApiName> apiMethods = new HashMap<>();

        List<String> nullableArgs;

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleSheetsApiName.SPREADSHEETS, new ApiMethodHelper<>(SheetsSpreadsheetsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(SheetsSpreadsheetsApiMethod.class, GoogleSheetsApiName.SPREADSHEETS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleSheetsApiName.DATA, new ApiMethodHelper<>(SheetsSpreadsheetsValuesApiMethod.class, aliases, nullableArgs));
        apiMethods.put(SheetsSpreadsheetsValuesApiMethod.class, GoogleSheetsApiName.DATA);

        setApiHelpers(apiHelpers);
        setApiMethods(apiMethods);
    }

    public void setFieldsLength(String fieldsLength) {
        if (fieldsLength != null) {
            String[] outputArray = fieldsLength.split(",");
            outputFieldsLengthArray = new Integer[outputArray.length];
            for (int i = 0; i < outputArray.length; i++) {
                String str = outputArray[i];
                outputFieldsLengthArray[i] = Integer.parseInt(str);
            }
        }
    }

    private void getPartialObject(MinioClient minioClient, Exchange exchange) throws Exception {

        if (getConfiguration().isPojoRequest()) {
            GetObjectArgs.Builder payload = exchange.getIn().getMandatoryBody(GetObjectArgs.Builder.class);
            if (isNotEmpty(payload)) {
                InputStream respond = minioClient.getObject(payload.build());
                Message message = getMessageForResponse(exchange);
                message.setBody(respond);
            }
        } else {
            final String bucketName = determineBucketName(exchange);
            final String sourceKey = determineObjectName(exchange);
            final String offset = exchange.getIn().getHeader(MinioConstants.OFFSET, String.class);
            final String length = exchange.getIn().getHeader(MinioConstants.LENGTH, String.class);

            if (isEmpty(offset) || isEmpty(length)) {
                throw new IllegalArgumentException(
                        "A Offset and length header must be configured to perform a partial get operation.");
            }

            InputStream respond = minioClient.getObject(GetObjectArgs.builder()
                    .bucket(bucketName)
                    .object(sourceKey)
                    .offset(Long.parseLong(offset))
                    .length(Long.parseLong(length))
                    .build());

            Message message = getMessageForResponse(exchange);
            message.setBody(respond);
        }
    }

    public Map<String, Object> toMap() {
        JsonObject jo = new JsonObject();
        jo.put("camelVersion", version);
        jo.put("runtime", runtime);
        if (runtimeVersion != null) {
            jo.put("runtimeVersion", runtimeVersion);
        }
        if (description != null) {
            jo.put("description", description);
        }
        return jo;
    }

    public static <T> Supplier<T> memorize(ThrowingSupplier<T, ? extends Exception> supplier, Consumer<Exception> consumer) {
        final AtomicReference<T> valueHolder = new AtomicReference<>();
        return new Supplier<>() {
            @Override
            public T get() {
                T supplied = valueHolder.get();
                if (supplied == null) {
                    synchronized (valueHolder) {
                        supplied = valueHolder.get();
                        if (supplied == null) {
                            try {
                                supplied = Objects.requireNonNull(supplier.get(), "Supplier should not return null");
                                valueHolder.lazySet(supplied);
                            } catch (Exception e) {
                                consumer.accept(e);
                            }
                        }
                    }
                }
                return supplied;
            }
        };
    }

    private static String doLoad(File file, String kind) {
        try {
            String json = PackageHelper.loadText(file);
            if (Objects.equals(kind, PackageHelper.getSchemaKind(json))) {
                return json;
            }
        } catch (IOException ignored) {
             
        }
        return null;
    }

    public Future<Exchange> asyncSend() {
        DefaultFluentProducerTemplate clone = checkCloned();

         
        final Endpoint target = clone.target();

        Future<Exchange> result;
        Exchange exchange = clone.exchangeSupplier != null ? clone.exchangeSupplier.get() : null;
        if (exchange != null) {
            result = clone.template().asyncSend(target, exchange);
        } else {
            Processor proc = clone.processorSupplier != null ? clone.processorSupplier.get() : null;
            final Processor processor = proc != null ? proc : clone.defaultAsyncProcessor();
            result = clone.template().asyncSend(target, processor);
        }

         
        cloned = false;
        useDefaultEndpoint = true;

        return result;
    }

    public String browseMessageAsXml(Integer index, Boolean includeBody) {
        List<Exchange> exchanges = getEndpoint().getExchanges();

        if (index >= exchanges.size()) {
            return null;
        }
        Exchange exchange = exchanges.get(index);
        if (exchange == null) {
            return null;
        }

        Message msg = exchange.getMessage();
        return MessageHelper.dumpAsXml(msg, includeBody);
    }

    public static ApplicationPkcs7MimeCompressedDataEntity parseApplicationPkcs7MimeCompressedDataEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            ContentType contentType,
            String contentTransferEncoding)
            throws ParseException {

        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {
            byte[] compressedContent = parseBodyPartBytes(inbuffer, is, boundary, contentType, contentTransferEncoding);
            return new ApplicationPkcs7MimeCompressedDataEntity(compressedContent, contentTransferEncoding, false);
        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse PKCS7 Mime entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (requestClass.isInstance(payload)) {
                try {
                    result = pojoExecutor.apply(requestClass.cast(payload));
                } catch (AwsServiceException ase) {
                    LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                    throw ase;
                }
                LOG.trace("{} request performing", operationName);
            } else {
                throw new IllegalArgumentException(
                        String.format("Expected body of type %s but was %s",
                                requestClass.getName(),
                                payload != null ? payload.getClass().getName() : "null"));
            }
        } else {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    public Expression createExpression(CamelContext camelContext, String expression) throws SimpleParserException {
        return new Expression() {
            @Override
            public <T> T evaluate(Exchange exchange, Class<T> type) {
                if (type == Object.class || type == Boolean.class || type == boolean.class) {
                    return (T) Boolean.valueOf(value);
                }
                return camelContext.getTypeConverter().tryConvertTo(type, exchange, value);
            }

            @Override
            public String toString() {
                return String.valueOf(value);
            }
        };
    }

        protected boolean setProperty(MarshalDefinition target, String propertyKey,
                String propertyName, Node node) {
            propertyKey = org.apache.camel.util.StringHelper.dashToCamelCase(propertyKey);
            switch(propertyKey) {
                case "dataFormatType": {
                    MappingNode val = asMappingNode(node);
                    setProperties(target, val);
                    break;
                }
                case "asn1": {
                    org.apache.camel.model.dataformat.ASN1DataFormat val = asType(node, org.apache.camel.model.dataformat.ASN1DataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "avro": {
                    org.apache.camel.model.dataformat.AvroDataFormat val = asType(node, org.apache.camel.model.dataformat.AvroDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "barcode": {
                    org.apache.camel.model.dataformat.BarcodeDataFormat val = asType(node, org.apache.camel.model.dataformat.BarcodeDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "base64": {
                    org.apache.camel.model.dataformat.Base64DataFormat val = asType(node, org.apache.camel.model.dataformat.Base64DataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "beanio": {
                    org.apache.camel.model.dataformat.BeanioDataFormat val = asType(node, org.apache.camel.model.dataformat.BeanioDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "bindy": {
                    org.apache.camel.model.dataformat.BindyDataFormat val = asType(node, org.apache.camel.model.dataformat.BindyDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "cbor": {
                    org.apache.camel.model.dataformat.CBORDataFormat val = asType(node, org.apache.camel.model.dataformat.CBORDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "crypto": {
                    org.apache.camel.model.dataformat.CryptoDataFormat val = asType(node, org.apache.camel.model.dataformat.CryptoDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "csv": {
                    org.apache.camel.model.dataformat.CsvDataFormat val = asType(node, org.apache.camel.model.dataformat.CsvDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "custom": {
                    org.apache.camel.model.dataformat.CustomDataFormat val = asType(node, org.apache.camel.model.dataformat.CustomDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "dfdl": {
                    org.apache.camel.model.dataformat.DfdlDataFormat val = asType(node, org.apache.camel.model.dataformat.DfdlDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "fhirJson": {
                    org.apache.camel.model.dataformat.FhirJsonDataFormat val = asType(node, org.apache.camel.model.dataformat.FhirJsonDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "fhirXml": {
                    org.apache.camel.model.dataformat.FhirXmlDataFormat val = asType(node, org.apache.camel.model.dataformat.FhirXmlDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "flatpack": {
                    org.apache.camel.model.dataformat.FlatpackDataFormat val = asType(node, org.apache.camel.model.dataformat.FlatpackDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "fory": {
                    org.apache.camel.model.dataformat.ForyDataFormat val = asType(node, org.apache.camel.model.dataformat.ForyDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "grok": {
                    org.apache.camel.model.dataformat.GrokDataFormat val = asType(node, org.apache.camel.model.dataformat.GrokDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "groovyXml": {
                    org.apache.camel.model.dataformat.GroovyXmlDataFormat val = asType(node, org.apache.camel.model.dataformat.GroovyXmlDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "gzipDeflater": {
                    org.apache.camel.model.dataformat.GzipDeflaterDataFormat val = asType(node, org.apache.camel.model.dataformat.GzipDeflaterDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "hl7": {
                    org.apache.camel.model.dataformat.HL7DataFormat val = asType(node, org.apache.camel.model.dataformat.HL7DataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "ical": {
                    org.apache.camel.model.dataformat.IcalDataFormat val = asType(node, org.apache.camel.model.dataformat.IcalDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "iso8583": {
                    org.apache.camel.model.dataformat.Iso8583DataFormat val = asType(node, org.apache.camel.model.dataformat.Iso8583DataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "jacksonXml": {
                    org.apache.camel.model.dataformat.JacksonXMLDataFormat val = asType(node, org.apache.camel.model.dataformat.JacksonXMLDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "jaxb": {
                    org.apache.camel.model.dataformat.JaxbDataFormat val = asType(node, org.apache.camel.model.dataformat.JaxbDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "json": {
                    org.apache.camel.model.dataformat.JsonDataFormat val = asType(node, org.apache.camel.model.dataformat.JsonDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "jsonApi": {
                    org.apache.camel.model.dataformat.JsonApiDataFormat val = asType(node, org.apache.camel.model.dataformat.JsonApiDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "lzf": {
                    org.apache.camel.model.dataformat.LZFDataFormat val = asType(node, org.apache.camel.model.dataformat.LZFDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "mimeMultipart": {
                    org.apache.camel.model.dataformat.MimeMultipartDataFormat val = asType(node, org.apache.camel.model.dataformat.MimeMultipartDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "parquetAvro": {
                    org.apache.camel.model.dataformat.ParquetAvroDataFormat val = asType(node, org.apache.camel.model.dataformat.ParquetAvroDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "protobuf": {
                    org.apache.camel.model.dataformat.ProtobufDataFormat val = asType(node, org.apache.camel.model.dataformat.ProtobufDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "rss": {
                    org.apache.camel.model.dataformat.RssDataFormat val = asType(node, org.apache.camel.model.dataformat.RssDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "smooks": {
                    org.apache.camel.model.dataformat.SmooksDataFormat val = asType(node, org.apache.camel.model.dataformat.SmooksDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "soap": {
                    org.apache.camel.model.dataformat.SoapDataFormat val = asType(node, org.apache.camel.model.dataformat.SoapDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "swiftMt": {
                    org.apache.camel.model.dataformat.SwiftMtDataFormat val = asType(node, org.apache.camel.model.dataformat.SwiftMtDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "swiftMx": {
                    org.apache.camel.model.dataformat.SwiftMxDataFormat val = asType(node, org.apache.camel.model.dataformat.SwiftMxDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "syslog": {
                    org.apache.camel.model.dataformat.SyslogDataFormat val = asType(node, org.apache.camel.model.dataformat.SyslogDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "tarFile": {
                    org.apache.camel.model.dataformat.TarFileDataFormat val = asType(node, org.apache.camel.model.dataformat.TarFileDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "thrift": {
                    org.apache.camel.model.dataformat.ThriftDataFormat val = asType(node, org.apache.camel.model.dataformat.ThriftDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "univocityCsv": {
                    org.apache.camel.model.dataformat.UniVocityCsvDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityCsvDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "univocityFixed": {
                    org.apache.camel.model.dataformat.UniVocityFixedDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityFixedDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "univocityTsv": {
                    org.apache.camel.model.dataformat.UniVocityTsvDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityTsvDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "xmlSecurity": {
                    org.apache.camel.model.dataformat.XMLSecurityDataFormat val = asType(node, org.apache.camel.model.dataformat.XMLSecurityDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "pgp": {
                    org.apache.camel.model.dataformat.PGPDataFormat val = asType(node, org.apache.camel.model.dataformat.PGPDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "yaml": {
                    org.apache.camel.model.dataformat.YAMLDataFormat val = asType(node, org.apache.camel.model.dataformat.YAMLDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "zipDeflater": {
                    org.apache.camel.model.dataformat.ZipDeflaterDataFormat val = asType(node, org.apache.camel.model.dataformat.ZipDeflaterDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "zipFile": {
                    org.apache.camel.model.dataformat.ZipFileDataFormat val = asType(node, org.apache.camel.model.dataformat.ZipFileDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "disabled": {
                    String val = asText(node);
                    target.setDisabled(val);
                    break;
                }
                case "variableReceive": {
                    String val = asText(node);
                    target.setVariableReceive(val);
                    break;
                }
                case "variableSend": {
                    String val = asText(node);
                    target.setVariableSend(val);
                    break;
                }
                case "id": {
                    String val = asText(node);
                    target.setId(val);
                    break;
                }
                case "description": {
                    String val = asText(node);
                    target.setDescription(val);
                    break;
                }
                case "note": {
                    String val = asText(node);
                    target.setNote(val);
                    break;
                }
                default: {
                    return false;
                }
            }
            return true;
        }

    protected void doCommit(Exchange exchange, String operation) throws GitAPIException {
        String commitMessage = null;
        String username = null;
        String email = null;
        if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(GitConstants.GIT_COMMIT_MESSAGE))) {
            commitMessage = exchange.getIn().getHeader(GitConstants.GIT_COMMIT_MESSAGE, String.class);
        } else {
            throw new IllegalArgumentException("Commit message must be specified to execute " + operation);
        }
        if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(GitConstants.GIT_COMMIT_USERNAME))
                && ObjectHelper.isNotEmpty(exchange.getIn().getHeader(GitConstants.GIT_COMMIT_EMAIL))) {
            username = exchange.getIn().getHeader(GitConstants.GIT_COMMIT_USERNAME, String.class);
            email = exchange.getIn().getHeader(GitConstants.GIT_COMMIT_EMAIL, String.class);
        }
        boolean allowEmpty = endpoint.isAllowEmpty();
        if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(GitConstants.GIT_ALLOW_EMPTY))) {
            allowEmpty = exchange.getIn().getHeader(GitConstants.GIT_ALLOW_EMPTY, Boolean.class);
        }

        try {
            if (ObjectHelper.isNotEmpty(endpoint.getBranchName())) {
                git.checkout().setCreateBranch(false).setName(endpoint.getBranchName()).call();
            }
            if (ObjectHelper.isNotEmpty(username) && ObjectHelper.isNotEmpty(email)) {
                git.commit().setAllowEmpty(allowEmpty).setCommitter(username, email).setMessage(commitMessage).call();
            } else {
                git.commit().setAllowEmpty(allowEmpty).setMessage(commitMessage).call();
            }
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
    }

    public static DataFormatModel generateDataFormatModel(JsonObject obj) {
        JsonObject mobj = (JsonObject) obj.get("dataformat");
        DataFormatModel model = new DataFormatModel();
        parseModel(mobj, model);
        parseArtifact(mobj, model);
        model.setModelName(mobj.getString("modelName"));
        model.setModelJavaType(mobj.getString("modelJavaType"));
        JsonObject mprp = (JsonObject) obj.get("properties");
        for (Map.Entry<String, Object> entry : mprp.entrySet()) {
            JsonObject mp = (JsonObject) entry.getValue();
            DataFormatOptionModel option = new DataFormatOptionModel();
            parseOption(mp, option, entry.getKey());
            model.addOption(option);
        }
        return model;
    }

    protected void doStart() throws Exception {
        super.doStart();

        String accessKey = System.getenv(CAMEL_AWS_VAULT_ACCESS_KEY_ENV);
        String secretKey = System.getenv(CAMEL_AWS_VAULT_SECRET_KEY_ENV);
        String region = System.getenv(CAMEL_AWS_VAULT_REGION_ENV);
        boolean useDefaultCredentialsProvider
                = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_USE_DEFAULT_CREDENTIALS_PROVIDER_ENV));
        boolean useProfileCredentialsProvider
                = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_USE_PROFILE_CREDENTIALS_PROVIDER_ENV));
        String profileName = System.getenv(CAMEL_AWS_VAULT_PROFILE_NAME_ENV);
        boolean isOverrideEndpoint = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_IS_OVERRIDE_ENDPOINT));
        String uriEndpointOverride = System.getenv(CAMEL_AWS_VAULT_URI_ENDPOINT_OVERRIDE);
        if (ObjectHelper.isEmpty(accessKey) && ObjectHelper.isEmpty(secretKey) && ObjectHelper.isEmpty(region)) {
            AwsVaultConfiguration awsVaultConfiguration = getCamelContext().getVaultConfiguration().aws();
            if (ObjectHelper.isNotEmpty(awsVaultConfiguration)) {
                accessKey = awsVaultConfiguration.getAccessKey();
                secretKey = awsVaultConfiguration.getSecretKey();
                region = awsVaultConfiguration.getRegion();
                useDefaultCredentialsProvider = awsVaultConfiguration.isDefaultCredentialsProvider();
                useProfileCredentialsProvider = awsVaultConfiguration.isProfileCredentialsProvider();
                profileName = awsVaultConfiguration.getProfileName();
                isOverrideEndpoint = awsVaultConfiguration.isOverrideEndpoint();
                uriEndpointOverride = awsVaultConfiguration.getUriEndpointOverride();
            }
        }
        this.region = region;
        if (ObjectHelper.isNotEmpty(accessKey) && ObjectHelper.isNotEmpty(secretKey) && ObjectHelper.isNotEmpty(region)) {
            SsmClientBuilder clientBuilder = SsmClient.builder();
            AwsBasicCredentials cred = AwsBasicCredentials.create(accessKey, secretKey);
            clientBuilder = clientBuilder.credentialsProvider(StaticCredentialsProvider.create(cred));
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else if (useDefaultCredentialsProvider && ObjectHelper.isNotEmpty(region)) {
            this.defaultCredentialsProvider = true;
            SsmClientBuilder clientBuilder = SsmClient.builder();
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else if (useProfileCredentialsProvider && ObjectHelper.isNotEmpty(profileName)) {
            this.profleCredentialsProvider = true;
            this.profileName = profileName;
            SsmClientBuilder clientBuilder = SsmClient.builder();
            clientBuilder.credentialsProvider(ProfileCredentialsProvider.create(profileName));
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else {
            throw new RuntimeCamelException(
                    "Using the AWS Parameter Store Properties Function requires setting AWS credentials as application properties or environment variables");
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            OpenTelemetrySpanAdapter camelSpan = (OpenTelemetrySpanAdapter) ActiveSpanManager.getSpan(exchange);
            if (camelSpan != null) {
                String item = expression.evaluate(exchange, String.class);
                camelSpan.setCorrelationContextItem(baggageName, item);
            } else {
                 
                LOG.debug("OpenTelemetry: Cannot find managed span for Exchange: {}", exchange);
            }
        } catch (Exception e) {
            exchange.setException(e);
        } finally {
             
            callback.done(true);
        }

        return true;
    }

    List<Row> collectRows() {
        List<Row> rows = new ArrayList<>();
        for (String name : catalog.findTransformerNames()) {
            TransformerModel model = catalog.transformerModel(name);
            if (model != null) {
                Row row = new Row();
                row.name = model.getName();
                row.title = model.getTitle();
                row.description = model.getDescription();
                row.deprecated = model.isDeprecated();
                row.gav = getGAV(model);
                rows.add(row);
            }
        }
        return rows;
    }

    public void setMessageDeduplicationIdStrategy(String strategy) {
        if ("useExchangeId".equalsIgnoreCase(strategy)) {
            messageDeduplicationIdStrategy = new ExchangeIdMessageDeduplicationIdStrategy();
        } else if ("useContentBasedDeduplication".equalsIgnoreCase(strategy)) {
            messageDeduplicationIdStrategy = new NullMessageDeduplicationIdStrategy();
        } else {
            throw new IllegalArgumentException("Unrecognised MessageDeduplicationIdStrategy: " + strategy);
        }
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.smooks.api.io.Source.class, org.apache.camel.WrappedFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.smooks.converter.SourceConverter.toURISource((org.apache.camel.WrappedFile) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.smooks.io.source.JavaSource.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.smooks.converter.SourceConverter.toJavaSource(value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.smooks.io.source.JavaSource.class, org.smooks.io.sink.JavaSink.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.smooks.converter.SourceConverter.toJavaSource((org.smooks.io.sink.JavaSink) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.smooks.io.source.JavaSourceWithoutEventStream.class, java.lang.Object.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.smooks.converter.SourceConverter.toJavaSourceWithoutEventStream(value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.smooks.io.source.StreamSource.class, java.io.InputStream.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.smooks.converter.SourceConverter.toStreamSource((java.io.InputStream) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.smooks.io.source.StringSource.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.smooks.converter.SourceConverter.toStringSource((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    protected boolean doHasNext() {
        try {
            if (zipInputStream == null) {
                return false;
            }
            boolean availableDataInCurrentEntry = currentEntry != null;
            if (!availableDataInCurrentEntry) {
                 
                parent = getNextElement();
                if (parent == null) {
                    zipInputStream.close();
                } else {
                    availableDataInCurrentEntry = true;
                }
            }
            return availableDataInCurrentEntry;
        } catch (IOException exception) {
            throw new RuntimeCamelException(exception);
        }
    }

    private static String longToHex(char[] seed, long v) {
        int l = seed.length;
        char[] hexChars = new char[16];
        System.arraycopy(seed, 0, hexChars, 0, l);
        for (int j = 9; j >= 0; j--) {
            hexChars[l + j] = HEX_ARRAY[(int) (v & 0x0F)];
            v >>= 4;
        }
        return new String(hexChars);
    }

    public static XQueryBuilder xquery(final InputStream in) {
        return new XQueryBuilder() {
            protected XQueryExpression createQueryExpression(StaticQueryContext staticQueryContext)
                    throws XPathException {
                try {
                    return staticQueryContext.compileQuery(in, ObjectHelper.getDefaultCharacterSet());
                } finally {
                    IOHelper.close(in);
                }
            }
        };
    }

    private void addRelevantProjectDependenciesToClasspath(List<URL> path, boolean testClasspathOnly)
            throws MojoExecutionException {
        try {
            getLog().debug("Project Dependencies will be included.");

            if (testClasspathOnly) {
                URL testClasses = new File(project.getBuild().getTestOutputDirectory()).toURI().toURL();

                if (getLog().isDebugEnabled()) {
                    getLog().debug("Adding to classpath : " + testClasses);
                }
                path.add(testClasses);
            } else {
                URL mainClasses = new File(project.getBuild().getOutputDirectory()).toURI().toURL();

                if (getLog().isDebugEnabled()) {
                    getLog().debug("Adding to classpath : " + mainClasses);
                }
                path.add(mainClasses);
            }

            Set<Artifact> dependencies = project.getArtifacts();

             
             
            dependencies.addAll(getAllNonTestScopedDependencies());

            for (Artifact classPathElement : dependencies) {
                if (getLog().isDebugEnabled()) {
                    getLog().debug("Adding project dependency artifact: " + classPathElement.getArtifactId()
                                   + " to classpath");
                }
                File file = classPathElement.getFile();
                if (file != null) {
                    path.add(file.toURI().toURL());
                }
            }

        } catch (MalformedURLException e) {
            throw new MojoExecutionException("Error during setting up classpath", e);
        }
    }

    public Integer doCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        if (pids.isEmpty()) {
            return 0;
        } else if (pids.size() > 1) {
            printer().println("Name or pid " + name + " matches " + pids.size()
                              + " running Camel integrations. Specify a name or PID that matches exactly one.");
            return 0;
        }

        this.pid = pids.get(0);

         
        Path outputFile = getOutputFile(Long.toString(pid));
        PathUtils.deleteFile(outputFile);

        JsonObject root = new JsonObject();
        root.put("action", "route-dump");
        root.put("filter", "*");
        root.put("format", format);
        root.put("uriAsParameters", uriAsParameters);
        Path file = getActionFile(Long.toString(pid));
        try {
            Files.writeString(file, root.toJson());
        } catch (Exception e) {
             
        }

        JsonObject jo = waitForOutputFile(outputFile);
        if (jo != null) {
            JsonArray arr = (JsonArray) jo.get("routes");
            for (int i = 0; i < arr.size(); i++) {
                JsonObject o = (JsonObject) arr.get(i);
                Row row = new Row();
                row.location = extractSourceName(o.getString("source"));
                row.routeId = o.getString("routeId");
                if (!rows.contains(row)) {
                    List<JsonObject> lines = o.getCollection("code");
                    if (lines != null) {
                        for (JsonObject line : lines) {
                            Code code = new Code();
                            code.line = line.getInteger("line");
                            code.code = line.getString("code");
                            row.code.add(code);
                        }
                    }
                    boolean add = true;
                    if (filter != null) {
                        String f = filter;
                        boolean negate = filter.startsWith("-");
                        if (negate) {
                            f = f.substring(1);
                        }
                         
                        if (!f.endsWith("*")) {
                            f += "*";
                        }
                        boolean match
                                = PatternHelper.matchPattern(row.location, f) || PatternHelper.matchPattern(row.routeId, f);
                        if (negate) {
                            match = !match;
                        }
                        if (!match) {
                            add = false;
                        }
                    }
                    if (add) {
                        rows.add(row);
                    }
                }
            }
        } else {
            printer().println("Response from running Camel with PID " + pid + " not received within 5 seconds");
            return 1;
        }

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printSource(rows);
        }

         
        PathUtils.deleteFile(outputFile);

        return 0;
    }

    public Processor createProcessor() throws Exception {
        ObjectHelper.notNull(definition.getName(), "headerName");
        Expression expr = createExpression(definition.getExpression());
        Expression nameExpr;
        String key = parseString(definition.getName());
        if (LanguageSupport.hasSimpleFunction(key)) {
            nameExpr = camelContext.resolveLanguage("simple").createExpression(key);
        } else {
            nameExpr = camelContext.resolveLanguage("constant").createExpression(key);
        }
        nameExpr.init(camelContext);

        SetHeaderProcessor answer = new SetHeaderProcessor(nameExpr, expr);
        answer.setDisabled(isDisabled(camelContext, definition));
        return answer;
    }

    public int processBatch(Queue<Object> exchanges) throws Exception {
        int total = exchanges.size();
        int answer = total;
        if (this.maxMessagesPerPoll > 0 && total > this.maxMessagesPerPoll) {
            LOG.debug("Limiting to maximum messages to poll {} as there were {} messages in this poll.",
                    this.maxMessagesPerPoll, total);
            total = this.maxMessagesPerPoll;
        }

        for (int index = 0; index < total && this.isBatchAllowed(); ++index) {
            Exchange exchange = (Exchange) exchanges.poll();
            exchange.setProperty(ExchangePropertyKey.BATCH_INDEX, index);
            exchange.setProperty(ExchangePropertyKey.BATCH_SIZE, total);
            exchange.setProperty(ExchangePropertyKey.BATCH_COMPLETE, index == total - 1);
            this.pendingExchanges = total - index - 1;
            this.lastSha = exchange.getMessage().getHeader(GitHubConstants.GITHUB_COMMIT_SHA, String.class);
            getProcessor().process(exchange);
        }

        return answer;
    }

    private Function<Exchange, Object> updateDocument() {
        return exchange -> {
            try {
                ArangoCollection collection = calculateDocumentCollection();

                boolean isMultiUpdate = exchange.getMessage().getHeader(MULTI_UPDATE, false, Boolean.class);

                 
                if (isMultiUpdate) {
                    Collection<Object> documents = exchange.getMessage().getMandatoryBody(Collection.class);
                    return collection.updateDocuments(documents);
                }

                 
                String key = (String) exchange.getMessage().getHeader(ARANGO_KEY);
                Object document = exchange.getMessage().getMandatoryBody();
                return collection.updateDocument(key, document);
            } catch (InvalidPayloadException e) {
                throw new RuntimeCamelException(INVALID_PAYLOAD_MESSAGE, e);
            }
        };
    }

    private void getVectors(S3VectorsClient client, Exchange exchange) {
        Message message = exchange.getIn();
        String vectorBucketName = determineVectorBucketName(exchange);
        String vectorIndexName = determineVectorIndexName(exchange);

         
        Object vectorIdsObj = message.getHeader(AWS2S3VectorsConstants.VECTOR_ID);
        if (vectorIdsObj == null) {
            vectorIdsObj = message.getBody();
        }

        List<String> vectorIds = convertToStringList(vectorIdsObj);

         
        GetVectorsRequest request = GetVectorsRequest.builder()
                .vectorBucketName(vectorBucketName)
                .indexName(vectorIndexName)
                .keys(vectorIds)
                .build();

        LOG.trace("Getting vectors [{}] from bucket [{}] index [{}]", vectorIds, vectorBucketName, vectorIndexName);
        GetVectorsResponse response = client.getVectors(request);
        LOG.trace("Get vectors response: {}", response);

        message.setBody(response.vectors());
    }

    private String getSecretFromSource(
            String key, String subkey, String defaultValue, String version)
            throws JsonProcessingException {
        String returnValue;

         
        secrets.add(key);

        try {
            KeyVaultSecret secret = client.getSecret(key, ObjectHelper.isNotEmpty(version) ? version : "");
            returnValue = secret.getValue();
            if (ObjectHelper.isNotEmpty(subkey)) {
                ObjectMapper mapper = new ObjectMapper();
                JsonNode actualObj = mapper.readTree(returnValue);
                JsonNode field = actualObj.get(subkey);
                if (ObjectHelper.isNotEmpty(field)) {
                    returnValue = field.textValue();
                } else {
                    returnValue = null;
                }
            }
            if (ObjectHelper.isEmpty(returnValue)) {
                returnValue = defaultValue;
            }
        } catch (ResourceNotFoundException ex) {
            if (ObjectHelper.isNotEmpty(defaultValue)) {
                returnValue = defaultValue;
            } else {
                throw ex;
            }
        }
        return returnValue;
    }

                public void eventReceived(Action action, Event resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

    private void updateFaceDetectionConfigurations(Exchange exchange, ClientConfigurations clientConfigurations) {
        String imageBase64 = exchange.getProperty(FaceRecognitionProperties.FACE_IMAGE_BASE64, String.class);
        clientConfigurations.setImageBase64(StringUtils.isEmpty(imageBase64) ? this.endpoint.getImageBase64() : imageBase64);
        if (!StringUtils.isEmpty(clientConfigurations.getImageBase64())) {
            clientConfigurations.setInputSourceType(InputSourceType.BASE64);
            return;
        }
        String imageUrl = exchange.getProperty(FaceRecognitionProperties.FACE_IMAGE_URL, String.class);
        clientConfigurations.setImageUrl(StringUtils.isEmpty(imageUrl) ? this.endpoint.getImageUrl() : imageUrl);
        if (!StringUtils.isEmpty(clientConfigurations.getImageUrl())) {
            clientConfigurations.setInputSourceType(InputSourceType.URL);
            return;
        }
        String imageFilePath = exchange.getProperty(FaceRecognitionProperties.FACE_IMAGE_FILE_PATH, String.class);
        clientConfigurations
                .setImageFilePath(StringUtils.isEmpty(imageFilePath) ? this.endpoint.getImageFilePath() : imageFilePath);
        if (!StringUtils.isEmpty(clientConfigurations.getImageFilePath())) {
            clientConfigurations.setInputSourceType(InputSourceType.FILE_PATH);
            return;
        }
        throw new IllegalArgumentException("any one of image base64, url and filePath needs to be set");
    }

    public void performUpdate(final Message message, AsyncCallback callback) {
        String filterId;
        if (message.getBody() instanceof DynamicRouterControlMessage) {
            filterId = subscribeFromMessage(dynamicRouterControlService, message, true);
        } else {
            filterId = subscribeFromHeaders(dynamicRouterControlService, message, true);
        }
        message.setBody(filterId);
        callback.done(false);
    }

    public Expression createExpression(
            CamelContext camelContext, Annotation annotation,
            LanguageAnnotation languageAnnotation, Class<?> expressionReturnType) {

        Object[] params = new Object[3];
        Class<?> resultType = getResultType(annotation);
        if (resultType.equals(Object.class)) {
            resultType = expressionReturnType;
        }
        params[0] = resultType;
        if (annotation instanceof Java) {
            Java joorAnnotation = (Java) annotation;
            params[1] = joorAnnotation.preCompile();
            params[2] = joorAnnotation.singleQuotes();
        }
        String expression = getExpressionFromAnnotation(annotation);
        return camelContext.resolveLanguage("java").createExpression(expression, params);
    }

    private DaprOperationResponse waitForInstanceStart(Exchange exchange, DaprWorkflowClient client) {
        String instanceId = configurationOptionsProxy.getWorkflowInstanceId(exchange);
        Duration timeout = configurationOptionsProxy.getTimeout(exchange);
        boolean getWorkflowIO = configurationOptionsProxy.getWorkflowIO(exchange);

        try {
            WorkflowInstanceStatus response = client.waitForInstanceStart(instanceId, timeout, getWorkflowIO);
            return DaprOperationResponse.createFromWorkflowStatus(response);
        } catch (TimeoutException exception) {
            throw new RuntimeCamelException(
                    "Workflow instance " + instanceId + " could not be started in " + timeout, exception);
        }
    }

    public Float getFloat(final String key) {
        Object returnable = this.get(key);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).floatValue();
    }

    private Exchange createExchangeFromBlob(final String blobName, final BlobContainerClient blobContainerClient)
            throws IOException {
        final BlobClientWrapper clientWrapper
                = new BlobClientWrapper(blobContainerClient.getBlobClient(blobName));
        final BlobOperations operations = new BlobOperations(getEndpoint().getConfiguration(), clientWrapper);
        final Exchange exchange = createExchange(true);

        BlobOperationResponse response;
        if (!ObjectHelper.isEmpty(getEndpoint().getConfiguration().getFileDir())) {
             
            response = operations.downloadBlobToFile(exchange);
        } else {
             
            response = operations.getBlob(exchange);
        }

        getEndpoint().setResponseOnExchange(response, exchange);

        exchange.getIn().setHeader(BlobConstants.BLOB_NAME, blobName);
        return exchange;
    }

    public SchedulerFactory getSchedulerFactory() {
        if (schedulerFactory == null) {
            try {
                schedulerFactory = createSchedulerFactory();
            } catch (SchedulerException e) {
                throw new RuntimeException(e);
            }
        }
        return schedulerFactory;
    }

    public void onStart(Route route) {
         
         
         
        statisticsMap.computeIfAbsent(route,
                it -> {
                    boolean skip = !configuration.isRouteEnabled();
                     
                    if (!skip) {
                        skip = (it.isCreatedByKamelet() && !registerKamelets)
                                || (it.isCreatedByRouteTemplate() && !registerTemplates);
                    }
                    if (!skip && configuration.getExcludePattern() != null) {
                        String[] patterns = configuration.getExcludePattern().split(",");
                        skip = PatternHelper.matchPatterns(route.getRouteId(), patterns);
                    }
                    LOG.debug("Capturing metrics for route: {} -> {}", route.getRouteId(), skip);
                    if (skip) {
                        return null;
                    }
                    return new MetricsStatistics(
                            getMeterRegistry(), it.getCamelContext(), it, getNamingStrategy(), configuration);
                });
    }

    private ClientConfigurations initializeConfigurations(ImageRecognitionEndpoint endpoint) {
        ClientConfigurations clientConfigurations = new ClientConfigurations();

        clientConfigurations.setAccessKey(getAccessKey(endpoint));
        clientConfigurations.setSecretKey(getSecretKey(endpoint));
        clientConfigurations.setProjectId(getProjectId(endpoint));
        clientConfigurations.setEndpoint(getEndpoint(endpoint));

        clientConfigurations.setIgnoreSslVerification(endpoint.isIgnoreSslVerification());
        if (clientConfigurations.isIgnoreSslVerification()) {
            LOG.warn("SSL verification is ignored. This is unsafe in production environment");
        }
        if (!StringUtils.isEmpty(endpoint.getProxyHost())) {
            clientConfigurations.setProxyHost(endpoint.getProxyHost());
            clientConfigurations.setProxyPort(endpoint.getProxyPort());
            clientConfigurations.setProxyUser(endpoint.getProxyUser());
            clientConfigurations.setProxyPassword(endpoint.getProxyPassword());
        }
        return clientConfigurations;
    }

    private void userSelectedHeadersMDC(Exchange exchange, boolean push) {
        for (String customHeader : getCustomHeaders().split(",")) {
            if (exchange.getIn().getHeader(customHeader) != null) {
                if (push) {
                    MDC.put(customHeader, exchange.getIn().getHeader(customHeader, String.class));
                } else {
                    MDC.remove(customHeader);
                }
            }
        }
    }

    public String dumpStatisticsAsJsonTimeUnitSeconds() {
        ObjectWriter writer = secondsMapper.writer();
        if (isPrettyPrint()) {
            writer = writer.withDefaultPrettyPrinter();
        }
        try {
            return writer.writeValueAsString(getMetricsRegistry());
        } catch (JsonProcessingException e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    public boolean process(final Exchange exchange, final AsyncCallback callback) {
         
        final Map<String, Object> properties = new HashMap<>(endpoint.getEndpointProperties());
        propertiesHelper.getExchangeProperties(exchange, properties);

         
        endpoint.interceptProperties(properties);
        interceptProperties(properties);

         
        properties.put(Olingo4Endpoint.RESPONSE_HANDLER_PROPERTY, new Olingo4ResponseHandler<Object>() {
            @Override
            public void onResponse(Object response, Map<String, String> responseHeaders) {
                if (resultIndex != null) {
                    response = resultIndex.filterResponse(response);
                }

                 
                 
                exchange.getOut().setBody(response);
                 
                exchange.getOut().setHeaders(exchange.getIn().getHeaders());

                 
                exchange.getOut().setHeader(Olingo4Constants.FULL_RESPONSE_HTTP_HEADERS, responseHeaders);

                interceptResult(response, exchange);

                callback.done(false);
            }

            @Override
            public void onException(Exception ex) {
                exchange.setException(ex);
                callback.done(false);
            }

            @Override
            public void onCanceled() {
                exchange.setException(new RuntimeCamelException("OData HTTP Request cancelled!"));
                callback.done(false);
            }
        });

         
        final ApiMethod method = findMethod(exchange, properties);
        if (method == null) {
             
            callback.done(true);
            return true;
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Invoking operation {} with {}", method.getName(), properties.keySet());
        }

        try {
            doInvokeMethod(method, properties);
        } catch (Exception e) {
            exchange.setException(RuntimeCamelException.wrapRuntimeCamelException(e));
            callback.done(true);
            return true;
        }
        return false;

    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {

        if (remaining == null || remaining.isBlank()) {
            throw new IllegalArgumentException("At least the account name must be specified.");
        }

        final BlobConfiguration config = this.configuration != null ? this.configuration.copy() : new BlobConfiguration();

        final String[] parts = remaining.split("/");

         
        config.setAccountName(parts[0]);

         
        if (parts.length > 1) {
            config.setContainerName(parts[1]);
        }

        final BlobEndpoint endpoint = new BlobEndpoint(uri, this, config);
        setProperties(endpoint, parameters);

        initCredentialConfig(config);
        validateConfigurations(config);

        return endpoint;
    }

    protected void collectResults(Exchange exchange, Object result) throws Exception {
        if (result instanceof DataSet) {
            DataSet dsResults = (DataSet) result;
            if (getEndpoint().isCollect()) {
                exchange.getIn().setBody(dsResults.collect());
            } else {
                exchange.getIn().setBody(result);
                exchange.getIn().setHeader(FlinkConstants.FLINK_DATASET_HEADER, result);
            }
        } else {
            exchange.getIn().setBody(result);
        }
    }

    private void delayOrScheduleLockRelease(Runnable r) throws InterruptedException {
        if (readLockIdempotentReleaseDelay > 0 && readLockIdempotentReleaseExecutorService != null) {
            LOG.debug("Scheduling read lock release task to run asynchronous delayed after {} millis",
                    readLockIdempotentReleaseDelay);
            readLockIdempotentReleaseExecutorService.schedule(r, readLockIdempotentReleaseDelay, TimeUnit.MILLISECONDS);
        } else if (readLockIdempotentReleaseDelay > 0) {
            LOG.debug("Delaying read lock release task {} millis", readLockIdempotentReleaseDelay);
            Thread.sleep(readLockIdempotentReleaseDelay);
            r.run();
        } else {
            r.run();
        }
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, byte[].class, io.netty.handler.codec.http.FullHttpResponse.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.netty.http.NettyHttpConverter.toBytes((io.netty.handler.codec.http.FullHttpResponse) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, io.netty.buffer.ByteBuf.class, org.apache.camel.component.netty.http.NettyChannelBufferStreamCache.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.netty.http.NettyHttpConverter.toByteBuf((org.apache.camel.component.netty.http.NettyChannelBufferStreamCache) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.io.InputStream.class, io.netty.handler.codec.http.FullHttpResponse.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.netty.http.NettyHttpConverter.toInputStream((io.netty.handler.codec.http.FullHttpResponse) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, io.netty.handler.codec.http.FullHttpResponse.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.netty.http.NettyHttpConverter.toString((io.netty.handler.codec.http.FullHttpResponse) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public Byte getByteOrDefault(final String key, final byte defaultValue) {
        Object returnable;
        if (this.containsKey(key)) {
            returnable = this.get(key);
        } else {
            return defaultValue;
        }
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).byteValue();
    }

    public static DocumentBuilderFactory createDocumentBuilderFactory() {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        factory.setIgnoringElementContentWhitespace(true);
        factory.setIgnoringComments(true);
        try {
             
            factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, Boolean.TRUE);
        } catch (ParserConfigurationException e) {
        }
        try {
             
            factory.setFeature("http://xml.org/sax/features/external-general-entities", false);
        } catch (ParserConfigurationException e) {
        }
        try {
             
            factory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
        } catch (ParserConfigurationException e) {
        }
         
        try {
            Class<?> smClass = ObjectHelper.loadClass("org.apache.xerces.util.SecurityManager");
            if (smClass != null) {
                Object sm = smClass.getDeclaredConstructor().newInstance();
                 
                factory.setAttribute("http://apache.org/xml/properties/security-manager", sm);
            }
        } catch (Exception e) {
        }
        return factory;
    }

    protected DataStreamCallback resolveDataStreamCallback(Exchange exchange) {
        if (exchange.getIn().getHeader(FlinkConstants.FLINK_DATASTREAM_CALLBACK_HEADER) != null) {
            return (DataStreamCallback) exchange.getIn().getHeader(FlinkConstants.FLINK_DATASTREAM_CALLBACK_HEADER);
        } else if (getEndpoint().getDataStreamCallback() != null) {
            return getEndpoint().getDataStreamCallback();
        } else {
            throw new IllegalArgumentException("Cannot resolve DataStream callback.");
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvents.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.azure.storage.blob.getBlob");

        if (message.getHeaders().containsKey(BlobConstants.E_TAG)) {
            headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SOURCE,
                    "azure.storage.blob." + message.getHeader(BlobConstants.E_TAG, String.class));
        }

        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(BlobConstants.BLOB_NAME, String.class));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvents.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

        public Olingo2BatchChangeRequest build() {
             
            if (request.resourcePath == null) {
                throw new IllegalArgumentException("Null resourcePath");
            }
            if (request.operation == null) {
                throw new IllegalArgumentException("Null operation");
            }
            if (request.operation != Operation.DELETE && request.body == null) {
                throw new IllegalArgumentException("Null body");
            }
            return request;
        }

    private void deleteKey(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
        Integer keyId = exchange.getIn().getHeader(DigitalOceanHeaders.ID, Integer.class);
        String fingerprint = exchange.getIn().getHeader(DigitalOceanHeaders.KEY_FINGERPRINT, String.class);
        Delete delete;

        if (ObjectHelper.isNotEmpty(keyId)) {
            delete = getEndpoint().getDigitalOceanClient().deleteKey(keyId);
        } else if (ObjectHelper.isNotEmpty(fingerprint)) {
            delete = getEndpoint().getDigitalOceanClient().deleteKey(fingerprint);
        } else {
            throw new IllegalArgumentException(
                    DigitalOceanHeaders.ID + " or " + DigitalOceanHeaders.KEY_FINGERPRINT + " must be specified");
        }

        LOG.trace("Delete Key {}", delete);
        exchange.getMessage().setBody(delete);
    }

    private void fetch(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();
        List elements = in.getMandatoryBody(List.class);
        String indexName = getEndpoint().getConfiguration().getIndexName();

        if (in.getHeader(PineconeVectorDbHeaders.INDEX_NAME, String.class) != null) {
            indexName = in.getHeader(PineconeVectorDbHeaders.INDEX_NAME, String.class);
        }

        Index index = this.client.getIndexConnection(indexName);

        FetchResponse result
                = index.fetch(elements);

        populateFetchResponse(result, exchange);
    }

    protected RouteTemplateDefinition createRouteTemplate() {
        RouteTemplateDefinition template = new RouteTemplateDefinition();
        ErrorHandlerFactory handler = getErrorHandlerFactory();
        if (handler != null) {
            template.getRoute().setErrorHandlerFactoryIfNull(handler);
        }
        if (resource != null) {
            template.setResource(resource);
        }
        return template;
    }

    private void updateUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                keycloakClient.realm(realmName).users().get(userId).update((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("User updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update user requires POJO request with UserRepresentation");
        }
    }

    public int forceCompletionOfGroup(String key) {
         
        int total = 0;

        lock.lock();
        try {
            Exchange exchange = aggregationRepository.get(camelContext, key);
            if (exchange != null) {
                total = 1;
                LOG.trace("Force completion triggered for correlation key: {}", key);
                 
                exchange.setProperty(ExchangePropertyKey.AGGREGATED_COMPLETED_BY, COMPLETED_BY_FORCE);
                Exchange answer = onCompletion(key, exchange, exchange, false, false);
                if (answer != null) {
                    onSubmitCompletion(key, answer);
                }
            }
        } finally {
            lock.unlock();
        }
        LOG.trace("Completed force completion of group {}", key);

        if (total > 0) {
            LOG.debug("Forcing completion of group {} with {} exchanges", key, total);
        }
        return total;
    }

    private Charset getEncodingParameter(String type, MinaConfiguration configuration) {
        String encoding = configuration.getEncoding();
        if (encoding == null) {
            encoding = Charset.defaultCharset().name();
             
            configuration.setEncoding(encoding);
            LOG.debug("{}: No encoding parameter using default charset: {}", type, encoding);
        }
        if (!Charset.isSupported(encoding)) {
            throw new IllegalArgumentException("The encoding: " + encoding + " is not supported");
        }

        return Charset.forName(encoding);
    }

    private void createMavenPom(Path settings, Path pom, Set<String> deps) throws Exception {
        String[] ids = gav.split(":");

        InputStream is = ExportQuarkus.class.getClassLoader().getResourceAsStream("templates/" + pomTemplateName);
        String context = IOHelper.loadText(is);
        IOHelper.close(is);

        Properties prop = new CamelCaseOrderedProperties();
        RuntimeUtil.loadProperties(prop, settings);
         
        String repos = getMavenRepositories(settings, prop, quarkusVersion);

        CamelCatalog catalog = CatalogLoader.loadQuarkusCatalog(repos, quarkusVersion, quarkusGroupId, download);
        if (camelVersion == null) {
            camelVersion = catalog.getCatalogVersion();
        }

        String mp = prop.getProperty("quarkus.management.port");
        if (mp == null) {
            mp = "9876";
        }

        context = context.replaceAll("\\{\\{ \\.GroupId }}", ids[0]);
        context = context.replaceAll("\\{\\{ \\.ArtifactId }}", ids[1]);
        context = context.replaceAll("\\{\\{ \\.Version }}", ids[2]);
        context = context.replaceAll("\\{\\{ \\.QuarkusGroupId }}", quarkusGroupId);
        context = context.replaceAll("\\{\\{ \\.QuarkusArtifactId }}", quarkusArtifactId);
        context = context.replaceAll("\\{\\{ \\.QuarkusVersion }}", quarkusVersion);
        context = context.replaceAll("\\{\\{ \\.QuarkusManagementPort }}", mp);
        context = context.replaceAll("\\{\\{ \\.JavaVersion }}", javaVersion);
        context = context.replaceAll("\\{\\{ \\.CamelVersion }}", camelVersion);
        context = context.replaceAll("\\{\\{ \\.ProjectBuildOutputTimestamp }}", this.getBuildMavenProjectDate());

        context = replaceBuildProperties(context);

        if (repos == null || repos.isEmpty()) {
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", "");
        } else {
            String s = mavenRepositoriesAsPomXml(repos);
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", s);
        }

        List<MavenGav> gavs = new ArrayList<>();
        for (String dep : deps) {
            MavenGav gav = parseMavenGav(dep);
            String gid = gav.getGroupId();
            String aid = gav.getArtifactId();
             
            if ("org.apache.camel".equals(gid)) {
                String qaid = aid.replace("camel-", "camel-quarkus-");
                ArtifactModel<?> am = catalog.modelFromMavenGAV("org.apache.camel.quarkus", qaid, null);
                if (am != null) {
                     
                    gav.setGroupId(am.getGroupId());
                    gav.setArtifactId(am.getArtifactId());
                    gav.setVersion(null);  
                } else {
                     
                    gav.setVersion(camelVersion);
                }
            }
            gavs.add(gav);
        }

         
        replaceQuarkusDependencies(gavs);

         
        gavs.sort(mavenGavComparator());

        StringBuilder sb = new StringBuilder();
        for (MavenGav gav : gavs) {
             
            if ("camel-quarkus-core".equals(gav.getArtifactId())
                    || "camel-quarkus-microprofile-health".equals(gav.getArtifactId())) {
                continue;
            }
            sb.append("        <dependency>\n");
            sb.append("            <groupId>").append(gav.getGroupId()).append("</groupId>\n");
            sb.append("            <artifactId>").append(gav.getArtifactId()).append("</artifactId>\n");
            if (gav.getVersion() != null) {
                sb.append("            <version>").append(gav.getVersion()).append("</version>\n");
            }
            if (gav.getScope() != null) {
                sb.append("            <scope>").append(gav.getScope()).append("</scope>\n");
            }
            if ("lib".equals(gav.getPackaging())) {
                 
                sb.append("            <scope>system</scope>\n");
                sb.append("            <systemPath>\\$\\{project.basedir}/lib/").append(gav.getArtifactId()).append("-")
                        .append(gav.getVersion()).append(".jar</systemPath>\n");
            } else if ("camel-kamelets-utils".equals(gav.getArtifactId())) {
                 
                sb.append("            <exclusions>\n");
                sb.append("                <exclusion>\n");
                sb.append("                    <groupId>org.apache.camel</groupId>\n");
                sb.append("                    <artifactId>*</artifactId>\n");
                sb.append("                </exclusion>\n");
                sb.append("            </exclusions>\n");
            }
            sb.append("        </dependency>\n");
        }
        context = context.replaceFirst("\\{\\{ \\.CamelDependencies }}", sb.toString());

        Files.writeString(pom, context);
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulHealthProducer target = (org.apache.camel.component.consul.endpoint.ConsulHealthProducer) obj;
        switch (key) {
        case "checks":
        case "CHECKS": target.checks(exchange.getMessage()); return null;
        case "node_checks":
        case "NODE_CHECKS": target.nodeChecks(exchange.getMessage()); return null;
        case "service_checks":
        case "SERVICE_CHECKS": target.serviceChecks(exchange.getMessage()); return null;
        case "service_instances":
        case "SERVICE_INSTANCES": target.serviceInstances(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public void close() {
        if (!closed) {
            try {
                ClearScrollRequest clearScrollRequest = new ClearScrollRequest.Builder()
                        .scrollId(List.of(scrollId))
                        .build();

                esClient.clearScroll(clearScrollRequest);
                closed = true;
                exchange.setProperty(OpensearchConstants.PROPERTY_SCROLL_OPENSEARCH_QUERY_COUNT, requestCount);
            } catch (IOException e) {
                throw new IllegalStateException(e);
            }
        }
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();
        if (propertiesFunction != null) {
            KubernetesClient client = propertiesFunction.getClient();
            if (client != null && client.getMasterUrl() != null) {
                root.put("masterUrl", client.getMasterUrl().toString());
                root.put("login", "OAuth Token");
            }
        }
        KubernetesVaultConfiguration kubernetes = getCamelContext().getVaultConfiguration().getKubernetesVaultConfiguration();
        if (kubernetes != null) {
            root.put("refreshEnabled", kubernetes.isRefreshEnabled());
        }
        if (secretsRefreshTask != null) {
            Instant start = secretsRefreshTask.getStartingTime();
            if (start != null) {
                long timestamp = start.toEpochMilli();
                root.put("startCheckTimestamp", timestamp);
            }
        }
        JsonArray arr = new JsonArray();
        root.put("secrets", arr);

        List<String> sorted = new ArrayList<>(List.of(kubernetes.getSecrets().split(",")));
        Collections.sort(sorted);

        for (String sec : sorted) {
            JsonObject jo = new JsonObject();
            jo.put("name", sec);
            arr.add(jo);
        }
        return root;
    }

    private void query(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();
        List elements = in.getMandatoryBody(List.class);
        String indexName = getEndpoint().getConfiguration().getIndexName();

        if (in.getHeader(PineconeVectorDbHeaders.INDEX_NAME, String.class) != null) {
            indexName = in.getHeader(PineconeVectorDbHeaders.INDEX_NAME, String.class);
        }

        int topK = in.getHeader(PineconeVectorDbHeaders.QUERY_TOP_K, Integer.class);
        Index index = this.client.getIndexConnection(indexName);

         
        String namespace = in.getHeader(PineconeVectorDbHeaders.NAMESPACE, String.class);
        Struct filter = in.getHeader(PineconeVectorDbHeaders.QUERY_FILTER, Struct.class);
        boolean includeValues = (in.getHeader(PineconeVectorDbHeaders.QUERY_INCLUDE_VALUES, Boolean.class) == null)
                ? false : in.getHeader(PineconeVectorDbHeaders.QUERY_INCLUDE_VALUES, Boolean.class);
        boolean includeMetadata = (in.getHeader(PineconeVectorDbHeaders.QUERY_INCLUDE_METADATA, Boolean.class) == null)
                ? false : in.getHeader(PineconeVectorDbHeaders.QUERY_INCLUDE_METADATA, Boolean.class);

        QueryResponseWithUnsignedIndices result
                = index.queryByVector(topK, elements, namespace, filter, includeValues, includeMetadata);

        populateQueryResponse(result, exchange);
    }

    public CompletableFuture<Void> complete(URL lra, Exchange exchange) {
        HttpRequest request = prepareRequest(URI.create(lra.toString() + COORDINATOR_PATH_CLOSE), exchange)
                .setHeader(CONTENT_TYPE, TEXT_PLAIN_CONTENT)
                .PUT(HttpRequest.BodyPublishers.ofString(""))
                .build();

        CompletableFuture<HttpResponse<String>> future = client.sendAsync(request, HttpResponse.BodyHandlers.ofString());

        return future.thenApply(response -> {
            if (response.statusCode() != HttpURLConnection.HTTP_OK) {
                throw new RuntimeCamelException("Cannot complete LRA");
            }

            return null;
        });
    }

    public Integer getInteger(final int index) {
        Object returnable = this.get(index);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).intValue();
    }

    public static void doWithClasses(Class<?> clazz, ClassCallback cc) throws IllegalArgumentException {
         
        Class<?>[] classes = clazz.getDeclaredClasses();
        for (Class<?> aClazz : classes) {
            try {
                cc.doWith(aClazz);
            } catch (IllegalAccessException ex) {
                throw new IllegalStateException("Shouldn't be illegal to access class '" + aClazz.getName() + "': " + ex);
            }
        }
    }

    protected void doStop() throws Exception {
        for (MainListener listener : listeners) {
            listener.beforeStop(this);
        }

        super.doStop();

        getCamelContext().stop();

        for (MainListener listener : listeners) {
            listener.afterStop(this);
        }
    }

    protected void loadResource(String resourceUri, XsltBuilder xslt) throws TransformerException, IOException {
        LOG.trace("{} loading schema resource: {}", this, resourceUri);
        Source source = xslt.getUriResolver().resolve(resourceUri, null);
        if (this.saxonReaderProperties != null) {
             
             
            source = createReaderForSource(source);
        }
        if (source == null) {
            throw new IOException("Cannot load schema resource " + resourceUri);
        } else {
            xslt.setTransformerSource(source);
        }
         
        setCacheCleared(false);
    }

    private String getUri(Row r) {
        String u = r.endpointUri;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    Consumer doCreateConsumer(
            CamelContext camelContext, Processor processor, String verb, String basePath, String uriTemplate,
            RestConfiguration configuration, Map<String, Object> parameters, boolean api)
            throws Exception {

        String path = basePath;
        if (uriTemplate != null) {
             
            if (uriTemplate.startsWith("/")) {
                path = path + uriTemplate;
            } else {
                path = path + "/" + uriTemplate;
            }
        }
        path = FileUtil.stripLeadingSeparator(path);

        String scheme = "http";
        String host = "";
        int port = 0;

         
        RestConfiguration config = configuration;
        if (config == null) {
            config = CamelContextHelper.getRestConfiguration(getCamelContext(), "netty-http");
        }
        if (config.getScheme() != null) {
            scheme = config.getScheme();
        }
        if (config.getHost() != null) {
            host = config.getHost();
        }
        int num = config.getPort();
        if (num > 0) {
            port = num;
        }

         
        String contextPath = config.getContextPath();
        if (ObjectHelper.isNotEmpty(contextPath)) {
            contextPath = FileUtil.stripTrailingSeparator(contextPath);
            contextPath = FileUtil.stripLeadingSeparator(contextPath);
            if (ObjectHelper.isNotEmpty(contextPath)) {
                path = contextPath + "/" + path;
            }
        }

         
        if (ObjectHelper.isEmpty(host)) {
            host = RestComponentHelper.resolveRestHostName(host, config);
        }

        Map<String, Object> map = RestComponentHelper.initRestEndpointProperties("netty-http", config);

         
        boolean cors = config.isEnableCORS();

        if (api) {
            map.put("matchOnUriPrefix", "true");
        }

        RestComponentHelper.addHttpRestrictParam(map, verb, cors);

        String url = RestComponentHelper.createRestConsumerUrl("netty-http", scheme, host, port, path, map);

        NettyHttpEndpoint endpoint = (NettyHttpEndpoint) camelContext.getEndpoint(url, parameters);

         
        Consumer consumer = endpoint.createConsumer(processor);
        if (config.getConsumerProperties() != null && !config.getConsumerProperties().isEmpty()) {
            setProperties(camelContext, consumer, config.getConsumerProperties());
        }

        return consumer;
    }

    public <T> T convertTo(Class<?> from, Class<T> to, Exchange exchange, Object value) throws TypeConversionException {
        try {
            Object obj = doConvertTo(from, to, exchange, value);
            return (T) obj;
        } catch (TypeConversionException e) {
            throw e;
        } catch (Exception e) {
            throw new TypeConversionException(value, to, e);
        }
    }

    protected void execute(Exchange exchange, NitriteEndpoint endpoint) throws Exception {
        ObjectRepository repository = (ObjectRepository) endpoint.getNitriteCollection();
        if (objectFilter != null && findOptions != null) {
            exchange.getMessage().setBody(repository.find(objectFilter, findOptions));
        } else if (objectFilter != null) {
            exchange.getMessage().setBody(repository.find(objectFilter));
        } else {
            exchange.getMessage().setBody(repository.find());
        }
    }

    public Integer doCall() throws Exception {
        List<Long> pids = findPids(name);
        for (long pid : pids) {
            JsonObject root = new JsonObject();
            root.put("action", "reload");
            Path f = getActionFile(Long.toString(pid));
            Files.writeString(f, root.toJson());
        }

        return 0;
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();

        List<FaultToleranceProcessor> cbs = new ArrayList<>();
        for (Route route : getCamelContext().getRoutes()) {
            List<Processor> list = route.filter("*");
            for (Processor p : list) {
                if (p instanceof FaultToleranceProcessor) {
                    cbs.add((FaultToleranceProcessor) p);
                }
            }
        }
         
        cbs.sort(Comparator.comparing(FaultToleranceProcessor::getId));

        final List<JsonObject> list = new ArrayList<>();
        for (FaultToleranceProcessor cb : cbs) {
            JsonObject jo = new JsonObject();
            jo.put("id", cb.getId());
            jo.put("routeId", cb.getRouteId());
            jo.put("state", cb.getCircuitBreakerState());
            list.add(jo);
        }
        root.put("circuitBreakers", list);

        return root;
    }

    private void unregister(Exchange exchange) throws ApiException {
        Message message = exchange.getMessage();
        TorchServeConfiguration configuration = getEndpoint().getConfiguration();
        String modelName = Optional
                .ofNullable(message.getHeader(TorchServeConstants.MODEL_NAME, String.class))
                .orElse(configuration.getModelName());
        String modelVersion = Optional
                .ofNullable(message.getHeader(TorchServeConstants.MODEL_VERSION, String.class))
                .orElse(configuration.getModelVersion());
        UnregisterOptions options = Optional
                .ofNullable(message.getHeader(TorchServeConstants.UNREGISTER_OPTIONS, UnregisterOptions.class))
                .or(() -> Optional.ofNullable(configuration.getUnregisterOptions()))
                .orElse(UnregisterOptions.empty());
        Response response;
        if (modelVersion == null) {
            response = this.management.unregisterModel(modelName, options);
        } else {
            response = this.management.unregisterModel(modelName, modelVersion, options);
        }
        message.setBody(response.getStatus());
    }

    protected void scheduleDelayedStart() {
        Runnable startRunnable = new Runnable() {
            @Override
            public void run() {
                try {
                    doStart();
                } catch (Exception e) {
                    LOG.warn("Ignoring an exception caught in the startup connection poller thread.", e);
                }
            }
        };
        LOG.info("Delaying XMPP consumer startup for endpoint {}. Trying again in {} seconds.",
                URISupport.sanitizeUri(endpoint.getEndpointUri()), endpoint.getConnectionPollDelay());
        getExecutor().schedule(startRunnable, endpoint.getConnectionPollDelay(), TimeUnit.SECONDS);
    }

    public void releaseExclusiveReadLockOnRollback(
            GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
            throws Exception {
        String key = asKey(exchange, file);
        if (removeOnRollback) {
            idempotentRepository.remove(exchange, key);
        } else {
             
            idempotentRepository.confirm(exchange, key);
        }

        rename.releaseExclusiveReadLockOnRollback(operations, file, exchange);
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        Message in = exchange.getIn();
        Message out = exchange.getOut();
        MessageHelper.copyHeaders(exchange.getIn(), out, true);

        switch (cacheOperationFor(exchange)) {

            case GET:
                doGet(in, out);
                break;

            case PUT:
                doPut(in, out);
                break;

            case QUERY:
                doQuery(in, out, exchange);
                break;

            case REMOVE:
                doRemove(in, out);
                break;

            case CLEAR:
                doClear(in, out);
                break;

            case SIZE:
                doSize(in, out);
                break;

            case REBALANCE:
                doRebalance(in, out);
                break;

            case REPLACE:
                doReplace(in, out);
                break;

            default:
                break;
        }

        callback.done(false);
        return false;
    }

    protected String getObjectName(String uriExpression) {
        String namespacedName = uriExpression;
        if (uriExpression.contains("?")) {
            namespacedName = StringHelper.before(uriExpression, "?");
        }

        if (namespacedName.contains("/")) {
            return namespacedName.split("/", 2)[1];
        }

        return namespacedName;
    }

    public void setLoggingFeatureEnabled(boolean loggingFeatureEnabled) {
        if (loggingFeature != null) {
            getFeatures().remove(loggingFeature);
            loggingFeature = null;
        }
        if (loggingFeatureEnabled) {
            if (getLoggingSizeLimit() > 0) {
                loggingFeature = new LoggingFeature();
                loggingFeature.setLimit(getLoggingSizeLimit());
            } else {
                loggingFeature = new LoggingFeature();
            }
            getFeatures().add(loggingFeature);
        }

    }

    public static Expression bodyOgnlExpression(final String ognl) {
        return new ExpressionAdapter() {
            private Language bean;

            @Override
            public Object evaluate(Exchange exchange) {
                Object body = exchange.getIn().getBody();
                if (body == null) {
                    return null;
                }
                Expression ognlExp = bean.createExpression(null, new Object[] { null, body, ognl });
                ognlExp.init(exchange.getContext());
                return ognlExp.evaluate(exchange, Object.class);
            }

            @Override
            public void init(CamelContext context) {
                bean = context.resolveLanguage("bean");
            }

            @Override
            public String toString() {
                return "bodyOgnl(" + ognl + ")";
            }
        };
    }

    private void generateComponentConfigurer(
            UriEndpoint uriEndpoint, String scheme, String[] schemes, ComponentModel componentModel,
            ComponentModel parentData) {

        if (!uriEndpoint.generateConfigurer()) {
            return;
        }
         
        if (isFirstScheme(scheme, schemes)) {
            return;
        }
        String pfqn;
        boolean hasSuper;

        Class<?> superClazz = loadClass(componentModel.getJavaType()).getSuperclass();
        if (parentData != null && superClazz.getName().equals(parentData.getJavaType())) {
             
            pfqn = parentData.getJavaType() + "Configurer";
            hasSuper = true;
        } else {
            pfqn = "org.apache.camel.support.component.PropertyConfigurerSupport";
            hasSuper = false;
            parentData = null;
        }
        String psn = pfqn.substring(pfqn.lastIndexOf('.') + 1);
        String fqComponentClassName = componentModel.getJavaType();
        String componentClassName = fqComponentClassName.substring(fqComponentClassName.lastIndexOf('.') + 1);
        String className = componentClassName + "Configurer";
        String packageName = fqComponentClassName.substring(0, fqComponentClassName.lastIndexOf('.'));
        String fqClassName = packageName + "." + className;

        List<ComponentOptionModel> options;
        if (parentData != null) {
            Set<String> parentOptionsNames = parentData.getComponentOptions().stream()
                    .map(ComponentOptionModel::getName).collect(Collectors.toSet());
            options = componentModel.getComponentOptions().stream().filter(o -> !parentOptionsNames.contains(o.getName()))
                    .toList();
        } else {
            options = componentModel.getComponentOptions();
        }
        generatePropertyConfigurer(packageName, className, fqClassName, componentClassName,
                pfqn, psn,
                componentModel.getScheme() + "-component", hasSuper, true,
                options, componentModel);
    }

    public void setSecureRandomName(String randomName) {
        if (context != null && randomName != null) {
            SecureRandom random = context.getRegistry().lookupByNameAndType(randomName, SecureRandom.class);
            if (keystore != null) {
                setSecureRandom(random);
            }
        }
        if (randomName != null) {
            this.secureRandomName = randomName;
        }
    }

    public void process(Exchange exchange) {
        if (exchange.getIn().getBody() instanceof String) {
            String input = exchange.getIn().getBody(String.class);
            T result = predict(exchange, input);
            exchange.getIn().setBody(result);
        } else {
            throw new RuntimeCamelException("Data type is not supported. Body should be String");
        }
    }

    public TabularData extendedInformation() {
        try {
            TabularData answer = new TabularDataSupport(CamelOpenMBeanTypes.endpointsUtilizationTabularType());

            EndpointUtilizationStatistics stats = getProcessor().getEndpointUtilizationStatistics();
            if (stats != null) {
                for (Map.Entry<String, Long> entry : stats.getStatistics().entrySet()) {
                    CompositeType ct = CamelOpenMBeanTypes.endpointsUtilizationCompositeType();
                    String url = entry.getKey();
                    if (sanitize) {
                        url = URISupport.sanitizeUri(url);
                    }

                    Long hits = entry.getValue();
                    if (hits == null) {
                        hits = 0L;
                    }

                    CompositeData data
                            = new CompositeDataSupport(ct, new String[] { "url", "hits" }, new Object[] { url, hits });
                    answer.put(data);
                }
            }
            return answer;
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    public E predecessor(E e) {
        E elem = lower(e);
        if (elem == null) {
            return null;
        }
        if (seqComparator().predecessor(elem, e)) {
            return elem;
        }
        return null;
    }

    protected int parseEpilog() throws XmlPullParserException, IOException {
        if (eventType == END_DOCUMENT) {
            throw new XmlPullParserException("already reached end of XML input", this, null);
        }
        if (reachedEnd) {
            return eventType = END_DOCUMENT;
        }
        boolean gotS = false;
        final boolean normalizeIgnorableWS = tokenize && !roundtripSupported;
        boolean normalizedCR = false;
        try {
             
            char ch;
            if (seenMarkup) {
                ch = buf[pos - 1];
            } else {
                ch = more();
            }
            seenMarkup = false;
            posStart = pos - 1;
            if (!reachedEnd) {
                while (true) {
                     
                     
                    if (ch == '<') {
                        if (gotS && tokenize) {
                            posEnd = pos - 1;
                            seenMarkup = true;
                            return eventType = IGNORABLE_WHITESPACE;
                        }
                        ch = more();
                        if (reachedEnd) {
                            break;
                        }
                        if (ch == '?') {
                             
                             
                            parsePI();
                            if (tokenize)
                                return eventType = PROCESSING_INSTRUCTION;

                        } else if (ch == '!') {
                            ch = more();
                            if (reachedEnd) {
                                break;
                            }
                            if (ch == 'D') {
                                parseDocdecl();  
                                if (tokenize)
                                    return eventType = DOCDECL;
                            } else if (ch == '-') {
                                parseComment();
                                if (tokenize)
                                    return eventType = COMMENT;
                            } else {
                                throw new XmlPullParserException("unexpected markup <!" + printable(ch), this, null);
                            }
                        } else if (ch == '/') {
                            throw new XmlPullParserException(
                                    "end tag not allowed in epilog but got " + printable(ch), this, null);
                        } else if (isNameStartChar(ch)) {
                            throw new XmlPullParserException(
                                    "start tag not allowed in epilog but got " + printable(ch), this, null);
                        } else {
                            throw new XmlPullParserException(
                                    "in epilog expected ignorable content and not " + printable(ch), this, null);
                        }
                    } else if (isS(ch)) {
                        gotS = true;
                        if (normalizeIgnorableWS) {
                            if (ch == '\r') {
                                normalizedCR = true;
                                 
                                 
                                 
                                if (!usePC) {
                                    posEnd = pos - 1;
                                    if (posEnd > posStart) {
                                        joinPC();
                                    } else {
                                        usePC = true;
                                        pcStart = pcEnd = 0;
                                    }
                                }
                                 
                                if (pcEnd >= pc.length)
                                    ensurePC(pcEnd);
                                pc[pcEnd++] = '\n';
                            } else if (ch == '\n') {
                                if (!normalizedCR && usePC) {
                                    if (pcEnd >= pc.length)
                                        ensurePC(pcEnd);
                                    pc[pcEnd++] = '\n';
                                }
                                normalizedCR = false;
                            } else {
                                if (usePC) {
                                    if (pcEnd >= pc.length)
                                        ensurePC(pcEnd);
                                    pc[pcEnd++] = ch;
                                }
                                normalizedCR = false;
                            }
                        }
                    } else {
                        throw new XmlPullParserException(
                                "in epilog non whitespace content is not allowed but got " + printable(ch), this, null);
                    }
                    ch = more();
                    if (reachedEnd) {
                        break;
                    }

                }
            }

             
             
             
        } catch (EOFException ex) {
            reachedEnd = true;
        }
        if (tokenize && gotS) {
            posEnd = pos;  
            return eventType = IGNORABLE_WHITESPACE;
        }
        return eventType = END_DOCUMENT;
    }